Deploy GitHub main cc65f516c16c41a528eec2ab762e0118fa11605c

.deploy/customer-ai-free-model

@@ -5,6 +5,8 @@ full-master-live-story-suite=blocked-without-notion-token
 hp-public-live-story-suite=100
 hp-public-bundled-pages=23
 hp-public-source-sha256=8c2de4259b00a4c64dc175bb76ed7187387db1c127e2f3de66fc21278490d8f5
-trigger=2026-07-29T22:55:00+09:00
+trigger=2026-08-10T13:29:00+09:00
 evidence=deployment-evidence/live-story-latest.json,deployment-evidence/hp-public-story-latest.json
 mode=private-space-internal-signed-routes
+public-routing=response_mode,mode_source,current_path
+conversation-lifecycle=preserve,minimize,new,delete

deployment-evidence/hp-public-story-latest.json

@@ -5,9 +5,13 @@
   "failed": 0,
   "score_percent": 0.0,
   "free_model_invoked": false,
-  "failure_stage": "before_hp_public_live_story_report",
+  "failure_stage": "hp_public_private_space_self_test_transport",
+  "error": "ReadError:[Errno 104] Connection reset by peer",
+  "space_id": "G-ACE/astera-customerAI",
+  "github_sha": "4d1e86831ecdedb419a1420985356e9c55082c4d",
+  "finished_at": "2026-07-29T14:04:15.831626+00:00",
   "workflow_status": "failure",
-  "workflow_run_id": "30457165765",
-  "workflow_sha": "32f7375882072d69812b38ba0c8ef616b18ff8e2",
-  "evidence_persisted_at": "2026-07-29T13:43:00.138648+00:00"
+  "workflow_run_id": "30458269214",
+  "workflow_sha": "4d1e86831ecdedb419a1420985356e9c55082c4d",
+  "evidence_persisted_at": "2026-07-29T14:04:16.687657+00:00"
 }

deployment-evidence/live-story-latest.json

@@ -5,9 +5,11 @@
   "failed": 0,
   "score_percent": 0.0,
   "free_model_invoked": false,
-  "failure_stage": "before_baseline_live_story_report",
+  "failure_stage": "full_master_notion_token_missing",
+  "verification_scope": "full_customerai_master_v2",
+  "finished_at": "2026-07-29T13:59:41.149535+00:00",
   "workflow_status": "failure",
-  "workflow_run_id": "30457165765",
-  "workflow_sha": "32f7375882072d69812b38ba0c8ef616b18ff8e2",
-  "evidence_persisted_at": "2026-07-29T13:43:00.138608+00:00"
+  "workflow_run_id": "30458269214",
+  "workflow_sha": "4d1e86831ecdedb419a1420985356e9c55082c4d",
+  "evidence_persisted_at": "2026-07-29T14:04:16.687552+00:00"
 }

edge/src/worker.js

@@ -1,4 +1,6 @@
 const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
+const RESPONSE_MODES = new Set(["general", "operation", "billing", "technical", "investor", "support", "trouble", "auto"]);
+const MODE_SOURCES = new Set(["selected", "auto", "confirmed"]);
 
 function json(body, status = 200, extra = {}) {
   return new Response(JSON.stringify(body), { status, headers: { ...JSON_HEADERS, ...extra } });
@@ -14,7 +16,7 @@ function corsHeaders(request, env) {
   if (!allowedOrigins(env).has(origin)) return {};
   return {
     "access-control-allow-origin": origin,
-    "access-control-allow-methods": "GET,POST,OPTIONS",
+    "access-control-allow-methods": "GET,POST,DELETE,OPTIONS",
     "access-control-allow-headers": "authorization,content-type,x-turnstile-token,x-astera-source,x-request-id",
     "access-control-max-age": "86400",
     vary: "Origin"
@@ -33,6 +35,11 @@ function isId(value, prefix) {
     && value.length <= 160;
 }
 
+function normalizePath(value) {
+  const path = String(value || "/").trim().split("?", 1)[0].split("#", 1)[0];
+  return path.startsWith("/") && !path.includes("://") ? path.slice(0, 512) || "/" : "/";
+}
+
 function textSafeEqual(left, right) {
   const a = new TextEncoder().encode(String(left));
   const b = new TextEncoder().encode(String(right));
@@ -55,10 +62,7 @@ function externalApiAuthorization(request, env) {
   if (!authorization) return { attempted: false, authorized: false };
   const token = bearerToken(request);
   const expected = String(env.CUSTOMER_AI_EXTERNAL_API_TOKEN || "");
-  return {
-    attempted: true,
-    authorized: Boolean(token && expected && textSafeEqual(token, expected))
-  };
+  return { attempted: true, authorized: Boolean(token && expected && textSafeEqual(token, expected)) };
 }
 
 async function bodyJson(request, maxBytes = 32768) {
@@ -87,9 +91,7 @@ async function verifyTurnstile(request, env, remoteIp) {
   form.set("idempotency_key", crypto.randomUUID());
   if (remoteIp) form.set("remoteip", remoteIp);
   const response = await fetch("https://challenges.cloudflare.com/turnstile/v0/siteverify", {
-    method: "POST",
-    body: form,
-    signal: AbortSignal.timeout(5000)
+    method: "POST", body: form, signal: AbortSignal.timeout(5000)
   });
   if (!response.ok) return false;
   const result = await response.json();
@@ -102,6 +104,15 @@ async function verifyTurnstile(request, env, remoteIp) {
   return true;
 }
 
+async function authorizePublicAction(request, env) {
+  if (!(await checkPublicRateLimit(request, env))) return { error: json({ error: "rate_limited", retry_after_seconds: 60 }, 429, { "retry-after": "60" }) };
+  const apiAuthorization = externalApiAuthorization(request, env);
+  if (apiAuthorization.attempted && !apiAuthorization.authorized) return { error: json({ error: "invalid_api_token" }, 401, { "www-authenticate": "Bearer" }) };
+  const remoteIp = request.headers.get("cf-connecting-ip") || "";
+  if (!apiAuthorization.authorized && !(await verifyTurnstile(request, env, remoteIp))) return { error: json({ error: "turnstile_failed" }, 403) };
+  return { apiAuthorization };
+}
+
 function decodeSecret(secret) {
   if (!secret) return new Uint8Array();
   if (!secret.startsWith("base64:")) return new TextEncoder().encode(secret);
@@ -122,15 +133,8 @@ async function verifyStandardWebhook(request, rawBody, secret, toleranceSeconds
   const seconds = Number(timestamp);
   if (!eventId || !Number.isInteger(seconds) || !signature || !secret) return false;
   if (Math.abs(Math.floor(Date.now() / 1000) - seconds) > toleranceSeconds) return false;
-  const key = await crypto.subtle.importKey(
-    "raw",
-    decodeSecret(secret),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const signed = `${eventId}.${timestamp}.${rawBody}`;
-  const digest = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(signed));
+  const key = await crypto.subtle.importKey("raw", decodeSecret(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const digest = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${eventId}.${timestamp}.${rawBody}`));
   const expected = base64(digest);
   return signature.split(/\s+/).some((candidate) => {
     const [version, encoded] = candidate.split(",", 2);
@@ -138,107 +142,97 @@ async function verifyStandardWebhook(request, rawBody, secret, toleranceSeconds
   });
 }
 
-async function submitMessage(request, env) {
-  if (!(await checkPublicRateLimit(request, env))) {
-    return json({ error: "rate_limited", retry_after_seconds: 60 }, 429, { "retry-after": "60" });
-  }
-
-  const apiAuthorization = externalApiAuthorization(request, env);
-  if (apiAuthorization.attempted && !apiAuthorization.authorized) {
-    return json({ error: "invalid_api_token" }, 401, { "www-authenticate": "Bearer" });
-  }
-
-  const remoteIp = request.headers.get("cf-connecting-ip") || "";
-  if (!apiAuthorization.authorized && !(await verifyTurnstile(request, env, remoteIp))) {
-    return json({ error: "turnstile_failed" }, 403);
+async function dispatchGateway(env, payload) {
+  const destinationId = String(env.CUSTOMER_AI_RUNTIME_DESTINATION_ID || "");
+  if (!env.WEBHOOK_INTERNAL_API_URL || !env.WEBHOOK_INTERNAL_API_TOKEN || !destinationId) {
+    return { response: null, payload: { error: "customer_ai_edge_not_configured" } };
   }
+  const response = await fetch(env.WEBHOOK_INTERNAL_API_URL, {
+    method: "POST",
+    headers: { authorization: `Bearer ${env.WEBHOOK_INTERNAL_API_TOKEN}`, "content-type": "application/json" },
+    body: JSON.stringify({ ...payload, destinationId })
+  });
+  const body = await response.json().catch(() => ({}));
+  return { response, payload: body };
+}
 
+async function submitMessage(request, env) {
+  const authorization = await authorizePublicAction(request, env);
+  if (authorization.error) return authorization.error;
   const input = await bodyJson(request, Number(env.MAX_INPUT_BYTES || 32768));
   const message = String(input.message || "").trim();
   if (!message) return json({ error: "message_required" }, 422);
-  if (message.length > Number(env.MAX_MESSAGE_CHARS || 20000)) {
-    return json({ error: "message_too_large" }, 413);
-  }
+  if (message.length > Number(env.MAX_MESSAGE_CHARS || 20000)) return json({ error: "message_too_large" }, 413);
 
-  const source = apiAuthorization.authorized
-    ? "astera-api"
-    : input.source === "astera-app" ? "astera-app" : "astera-hp";
+  const responseMode = String(input.response_mode || "auto");
+  const modeSource = String(input.mode_source || (responseMode === "auto" ? "auto" : "selected"));
+  if (!RESPONSE_MODES.has(responseMode)) return json({ error: "response_mode_invalid" }, 422);
+  if (!MODE_SOURCES.has(modeSource)) return json({ error: "mode_source_invalid" }, 422);
+
+  const apiAuthorization = authorization.apiAuthorization;
+  const source = apiAuthorization.authorized ? "astera-api" : input.source === "astera-app" ? "astera-app" : "astera-hp";
   const sessionId = isId(input.session_id, "session") ? input.session_id : id("session");
   const messageId = isId(input.message_id, "message") ? input.message_id : id("message");
   const jobId = isId(input.job_id, "job") ? input.job_id : id("job");
   const eventId = `event_${messageId}`;
-  const destinationId = String(env.CUSTOMER_AI_RUNTIME_DESTINATION_ID || "");
-  if (!env.WEBHOOK_INTERNAL_API_URL || !env.WEBHOOK_INTERNAL_API_TOKEN || !destinationId) {
-    return json({ error: "customer_ai_edge_not_configured" }, 503);
-  }
-
-  const gatewayResponse = await fetch(env.WEBHOOK_INTERNAL_API_URL, {
-    method: "POST",
-    headers: {
-      authorization: `Bearer ${env.WEBHOOK_INTERNAL_API_TOKEN}`,
-      "content-type": "application/json"
-    },
-    body: JSON.stringify({
-      eventId,
-      eventType: "customer.ai.message.requested",
-      sourceId: "cloudflare-customer-ai-edge",
-      destinationId,
-      subject: `job/${jobId}`,
-      data: {
-        job_id: jobId,
-        message: {
-          session_id: sessionId,
-          message_id: messageId,
-          message,
-          locale: String(input.locale || "ja-JP"),
-          source
-        }
+  const currentPath = normalizePath(input.current_path);
+  const gateway = await dispatchGateway(env, {
+    eventId,
+    eventType: "customer.ai.message.requested",
+    sourceId: "cloudflare-customer-ai-edge",
+    subject: `job/${jobId}`,
+    data: {
+      job_id: jobId,
+      message: {
+        session_id: sessionId, message_id: messageId, message,
+        locale: String(input.locale || "ja-JP"), source,
+        response_mode: responseMode, mode_source: modeSource, current_path: currentPath
       }
-    })
+    }
   });
-  const gatewayPayload = await gatewayResponse.json().catch(() => ({}));
-  if (!gatewayResponse.ok) {
-    return json({ error: "gateway_rejected", gateway: gatewayPayload }, 502);
-  }
+  if (!gateway.response) return json(gateway.payload, 503);
+  if (!gateway.response.ok) return json({ error: "gateway_rejected", gateway: gateway.payload }, 502);
 
   await env.CUSTOMER_AI_RESULTS.put(jobId, JSON.stringify({
-    job_id: jobId,
-    session_id: sessionId,
-    message_id: messageId,
-    status: "accepted",
+    job_id: jobId, session_id: sessionId, message_id: messageId, status: "accepted",
+    response_mode: responseMode, mode_source: modeSource, current_path: currentPath,
     created_at: new Date().toISOString()
   }), { expirationTtl: Number(env.RESULT_TTL_SECONDS || 3600) });
 
   return json({
-    ok: true,
-    job_id: jobId,
-    session_id: sessionId,
-    message_id: messageId,
-    status: "accepted",
-    gateway_event_id: gatewayPayload.eventId
+    ok: true, job_id: jobId, session_id: sessionId, message_id: messageId, status: "accepted",
+    response_mode: responseMode, mode_source: modeSource, current_path: currentPath,
+    gateway_event_id: gateway.payload.eventId
   }, 202);
 }
 
+async function deleteSession(request, env, sessionId) {
+  if (!isId(sessionId, "session")) return json({ error: "session_id_invalid" }, 422);
+  const authorization = await authorizePublicAction(request, env);
+  if (authorization.error) return authorization.error;
+  const eventId = id("event");
+  const gateway = await dispatchGateway(env, {
+    eventId,
+    eventType: "customer.ai.session.delete.requested",
+    sourceId: "cloudflare-customer-ai-edge",
+    subject: `session/${sessionId}`,
+    data: { session_id: sessionId, source: "astera-hp" }
+  });
+  if (!gateway.response) return json(gateway.payload, 503);
+  if (!gateway.response.ok) return json({ error: "gateway_rejected", gateway: gateway.payload }, 502);
+  return json({ ok: true, session_id: sessionId, status: "delete_requested", gateway_event_id: gateway.payload.eventId }, 202);
+}
+
 async function receiveEvent(request, env) {
   const raw = await request.text();
-  if (!(await verifyStandardWebhook(request, raw, env.RESULT_WEBHOOK_SECRET))) {
-    return json({ error: "invalid_standard_webhook_signature" }, 401);
-  }
+  if (!(await verifyStandardWebhook(request, raw, env.RESULT_WEBHOOK_SECRET))) return json({ error: "invalid_standard_webhook_signature" }, 401);
   const event = JSON.parse(raw);
   const data = event && typeof event.data === "object" ? event.data : {};
   const jobId = String(data.job_id || event.subject || "").replace(/^job\//, "");
   if (!isId(jobId, "job")) return json({ error: "job_id_invalid" }, 422);
   const existing = await env.CUSTOMER_AI_RESULTS.get(jobId, "json");
-  const value = {
-    ...(existing && typeof existing === "object" ? existing : {}),
-    ...data,
-    job_id: jobId,
-    event_type: event.type,
-    updated_at: new Date().toISOString()
-  };
-  await env.CUSTOMER_AI_RESULTS.put(jobId, JSON.stringify(value), {
-    expirationTtl: Number(env.RESULT_TTL_SECONDS || 3600)
-  });
+  const value = { ...(existing && typeof existing === "object" ? existing : {}), ...data, job_id: jobId, event_type: event.type, updated_at: new Date().toISOString() };
+  await env.CUSTOMER_AI_RESULTS.put(jobId, JSON.stringify(value), { expirationTtl: Number(env.RESULT_TTL_SECONDS || 3600) });
   return json({ ok: true, job_id: jobId }, 202);
 }
 
@@ -254,17 +248,17 @@ export default {
   async fetch(request, env) {
     const url = new URL(request.url);
     const cors = corsHeaders(request, env);
-    if (request.method === "OPTIONS") {
-      return new Response(null, { status: 204, headers: cors });
-    }
+    if (request.method === "OPTIONS") return new Response(null, { status: 204, headers: cors });
     const origin = request.headers.get("origin");
-    if (origin && !Object.keys(cors).length && url.pathname !== "/v1/customer-ai/events") {
-      return json({ error: "origin_not_allowed" }, 403);
-    }
+    if (origin && !Object.keys(cors).length && url.pathname !== "/v1/customer-ai/events") return json({ error: "origin_not_allowed" }, 403);
     try {
       let response;
-      if (request.method === "POST" && url.pathname === "/v1/customer-ai/messages") {
+      if (request.method === "GET" && url.pathname === "/v1/customer-ai/config") {
+        response = json({ turnstile_site_key: String(env.TURNSTILE_SITE_KEY || "") });
+      } else if (request.method === "POST" && url.pathname === "/v1/customer-ai/messages") {
         response = await submitMessage(request, env);
+      } else if (request.method === "DELETE" && url.pathname.startsWith("/v1/customer-ai/sessions/")) {
+        response = await deleteSession(request, env, decodeURIComponent(url.pathname.split("/").pop()));
       } else if (request.method === "POST" && url.pathname === "/v1/customer-ai/events") {
         response = await receiveEvent(request, env);
       } else if (request.method === "GET" && url.pathname.startsWith("/v1/customer-ai/jobs/")) {
@@ -279,11 +273,7 @@ export default {
       return new Response(response.body, { status: response.status, headers });
     } catch (error) {
       const code = error instanceof Error ? error.message : "internal_error";
-      return json(
-        { error: code === "BODY_TOO_LARGE" ? "body_too_large" : "internal_error" },
-        code === "BODY_TOO_LARGE" ? 413 : 500,
-        cors
-      );
+      return json({ error: code === "BODY_TOO_LARGE" ? "body_too_large" : "internal_error" }, code === "BODY_TOO_LARGE" ? 413 : 500, cors);
     }
   }
-};
+};

runtime/conversation.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import shutil
 import time
 from collections import OrderedDict
 from datetime import UTC, datetime
@@ -56,6 +57,13 @@ class ConversationCache:
         self.store.put_json(self._path(trimmed.session_id), trimmed.model_dump(mode="json"))
         self._remember(trimmed)
 
+    def delete(self, session_id: str) -> bool:
+        """Delete one bounded session from memory and persistent runtime state."""
+        existed = session_id in self._memory or (self.root / session_id).exists()
+        self._memory.pop(session_id, None)
+        shutil.rmtree(self.root / session_id, ignore_errors=True)
+        return existed
+
     def append_turns(
         self,
         context: SessionContext,

runtime/schemas.py

@@ -19,6 +19,17 @@ JobStatus = Literal[
     "completed",
     "failed",
 ]
+ResponseMode = Literal[
+    "general",
+    "operation",
+    "billing",
+    "technical",
+    "investor",
+    "support",
+    "trouble",
+    "auto",
+]
+ModeSource = Literal["selected", "auto", "confirmed"]
 
 
 class MessagePayload(BaseModel):
@@ -27,12 +38,23 @@ class MessagePayload(BaseModel):
     message: str = Field(min_length=1, max_length=20000)
     locale: Literal["ja-JP", "en"] = "ja-JP"
     source: Literal["astera-hp", "astera-app", "astera-api"]
+    response_mode: ResponseMode = "auto"
+    mode_source: ModeSource = "auto"
+    current_path: str = Field(default="/", max_length=512)
 
     @field_validator("session_id", "message_id")
     @classmethod
     def safe_identifier(cls, value: str) -> str:
         return validate_identifier(value)
 
+    @field_validator("current_path")
+    @classmethod
+    def safe_current_path(cls, value: str) -> str:
+        path = str(value or "/").strip()
+        if not path.startswith("/") or "://" in path:
+            return "/"
+        return path.split("?", 1)[0].split("#", 1)[0][:512] or "/"
+
 
 class ConversationTurn(BaseModel):
     role: Literal["user", "assistant"]

runtime/service.py

@@ -24,6 +24,15 @@ from .v8 import V8Supervisor
 
 LOGGER = logging.getLogger(__name__)
 SUPPORT_PIPELINE = "astera-customerai-master-v2-kb-only"
+RESPONSE_MODE_TOPICS = {
+    "general": "astera",
+    "operation": "operation",
+    "billing": "billing",
+    "technical": "technical",
+    "investor": "investor",
+    "support": "support",
+    "trouble": "troubleshooting",
+}
 
 
 class InternalEventApiClient:
@@ -170,6 +179,17 @@ class CustomerAIService:
         return {"recovered": recovered, "count": len(recovered)}
 
     async def accept(self, event: CloudEvent) -> tuple[dict[str, Any], bool]:
+        validate_identifier(event.id, field="event_id")
+        if event.type == "customer.ai.session.delete.requested":
+            session_id = validate_identifier(
+                str(event.data.get("session_id") or ""), field="session_id"
+            )
+            deleted = self.conversations.delete(session_id)
+            result = {"session_id": session_id, "deleted": deleted}
+            await self.events.emit(
+                "customer.ai.session.deleted", f"session/{session_id}", result
+            )
+            return result, True
         if event.type != "customer.ai.message.requested":
             raise ValueError("unsupported_event_type")
         payload = MessagePayload.model_validate(event.data["message"])
@@ -177,7 +197,6 @@ class CustomerAIService:
             raise ValueError("message_too_large")
         redacted = redact_text(payload.message)
         payload = payload.model_copy(update={"message": redacted.text})
-        validate_identifier(event.id, field="event_id")
         job_id = str(
             event.data.get("job_id")
             or "job_" + hashlib.sha256(event.id.encode()).hexdigest()[:32]
@@ -193,6 +212,9 @@ class CustomerAIService:
                 "job_id": job_id,
                 "created": created,
                 "redaction_kinds": redacted.kinds,
+                "response_mode": payload.response_mode,
+                "mode_source": payload.mode_source,
+                "current_path": payload.current_path,
             },
         )
         return record.model_dump(mode="json"), created
@@ -241,6 +263,21 @@ class CustomerAIService:
     async def _run_pipeline(
         self, job_id: str, request: MessagePayload
     ) -> dict[str, Any]:
+        context = self.conversations.get(request.session_id)
+        details = dict(context.confirmed_details)
+        details.update(
+            {
+                "response_mode": request.response_mode,
+                "mode_source": request.mode_source,
+                "current_path": request.current_path,
+            }
+        )
+        updates: dict[str, Any] = {"confirmed_details": details}
+        routed_topic = RESPONSE_MODE_TOPICS.get(request.response_mode)
+        if routed_topic:
+            updates["active_topic"] = routed_topic
+        self.conversations.save(context.model_copy(update=updates))
+
         outcome = await self.core.execute(request=request)
         return JobResult(
             job_id=job_id,
@@ -261,6 +298,12 @@ class CustomerAIService:
             "repair_attempted": outcome.repair_attempted,
             "feedback_candidate_id": outcome.feedback_candidate_id,
             "execution": outcome.execution,
+            "routing": {
+                "response_mode": request.response_mode,
+                "mode_source": request.mode_source,
+                "current_path": request.current_path,
+                "active_topic": routed_topic or context.active_topic,
+            },
         }
 
     def readiness(self) -> dict[str, Any]: