chore: sync deixic-node from Mono

.repository-projection.json

@@ -3,11 +3,11 @@
   "projection": "deixic-node",
   "projectionSchemaVersion": 1,
   "sourceRepository": "dx-corp/mono",
-  "sourceSha": "274db22a3ad92a0a22c45c0ecbc770f92c9d053d",
+  "sourceSha": "a971433d12b40d9042b3a64c2c074fa8fc398e69",
   "destinationRepository": "dx-corp/deixic-node",
-  "priorProjectedBase": "77f4e5fa7c3c2086d7581e6b5c1af7d137c03d72",
-  "definitionDigest": "6c8bda5a9e80c50ccdc2d79d85f61b7f2373eb695dcc86f51f6240901cdf3c28",
-  "toolDigest": "898e8657d9153a2a51d7c283bf83bb3350b5d1e6",
-  "contentDigest": "28995d4c14f796455f3ca5434951c10c6e1023438bf40a06894a534ba1007085",
+  "priorProjectedBase": "dbf984fd9e8fa133670a1baecc041d87dd8477b7",
+  "definitionDigest": "1984dfa11c2bd95dd871179573e2ab3783be7a6af86d9bf3cd0d1a3f10b15b86",
+  "toolDigest": "ff02edcbb40b0028af10ab01a101e918341f157a",
+  "contentDigest": "b2599945950a65ab6746aa14b8969fff44f412d4adf77f2d5549f1b8132c5ec9",
   "publicationEligible": true
 }

sdk/deixic/typescript/README.md

@@ -2,8 +2,7 @@
 
 `@evalops/deixic-sdk` is the supported TypeScript client for applications that
 submit Deixic tasks, follow durable progress, interrupt work, and approve or
-deny requested actions. It exposes that focused contract without publishing
-Deixic's browser-only API as an application interface.
+deny requested actions. Its top-level client exposes those supported methods.
 
 ## Install
 
@@ -45,34 +44,6 @@ and retrieves the final answer linked to that accepted turn, together with
 its referenced receipts. The lower-level `observeAcceptedTurn` helper remains
 available for callers that own their streaming policy.
 
-## Compliance assessments
-
-`deixic.compliance.assess()` evaluates a versioned control against a record
-fetched from its owning service under the client's fixed organization and
-workspace:
-
-```ts
-const { assessment } = await deixic.compliance.assess({
-  profileId: "dex-production-action-assurance/v1",
-  subjectKind: "tool_execution",
-  subjectId: "tex_123",
-});
-```
-
-The response names each requirement, its `ComplianceFindingStatus` value,
-a reason code and the owner reference. The first profile tags findings with
-the internal `DEX-ACTION-ASSURANCE` control; mapping that control to an
-external framework requires a separately reviewed mapping. Denied actions are `NOT_APPLICABLE`;
-executions without a confirmed succeeded state are `INDETERMINATE`. It includes a
-digest of the exact Tool Execution returned by the owner and declares coverage
-of one requested record. This is a live read. To retain a server-owned
-snapshot, call `deixic.compliance.record()` with the same subject and an
-`idempotencyKey`, then retrieve its `record.id` with `deixic.compliance.get()`.
-Repeating the key returns the first accepted snapshot. The current profile reports
-the independent Audit receipt as indeterminate because Tool Executor has no
-general Audit sink. Do not treat the result as proof of an external state
-change or of every action in a time window.
-
 ## Task handles and setup checks
 
 `await deixic.tasks.checkSetup({ channelId: "company" })` makes one read
@@ -221,3 +192,17 @@ retains the original Connect failure for advanced diagnostics.
 
 Node.js 20 or later is supported. The client also works in modern browsers
 when the application supplies an appropriate authenticated transport.
+
+## Public protocol boundary
+
+This package includes only the `deixicpublic.v1.DeixicPublicService` contract
+and its standard protobuf dependencies. Read responses expose public thread,
+message, event, setup, and receipt projections. Receipt evidence uses public
+resource references; service ownership and internal execution records are not
+part of this contract. Pagination uses page tokens.
+
+Existing `deixic.task.v1` checkpoints remain readable, including accepted turn
+IDs and decimal-string cursors. Their `channelId` identifies the public thread.
+Python message types are available from `deixic.protocol`; TypeScript exports
+public message types and schemas from the package root. Existing TypeScript
+operating-type names are aliases of these public types.

sdk/deixic/typescript/examples/account-brief.mjs

@@ -61,7 +61,7 @@ async function main() {
       writeAccess: check.writeAccess, nextAction: check.nextAction,
       requirements: check.capabilities.map(item => ({ service: item.service,
         missingRequirements: item.missingRequirements,
-        reasonCodes: item.missingRequirementStates.map(reason => reason.reasonCode) })),
+        accessible: item.accessible })),
       modelReady: check.selectedModel?.ready ?? null, errorKind: check.error?.kind,
       requestId: check.error?.requestId,
     }));
@@ -86,13 +86,13 @@ async function main() {
     else if (["approve", "deny"].includes(action)) {
       const result = await task.result();
       const event = result.event;
-      if (result.status !== "waiting" || !event || event.requestType !== OperatingThreadRequestType.APPROVAL
+      if (result.status !== "waiting" || !event || event.requestKind !== OperatingThreadRequestType.APPROVAL
         || event.requestId !== values.request) {
         console.log(JSON.stringify({ status: "needs_attention", reason: "approval_request_not_current" }));
         return 2;
       }
       await client.controls.respond({ channelId: task.checkpoint().channelId, turnId: result.turnId,
-        response: { requestId: event.requestId, callId: event.requestCallId, requestType: event.requestType,
+        response: { requestId: event.requestId, callId: event.callId, requestKind: event.requestKind,
           action: action === "approve" ? OperatingThreadResponseAction.APPROVE : OperatingThreadResponseAction.DENY },
         idempotencyKey: values["decision-key"],
       });
@@ -121,15 +121,15 @@ async function main() {
         }
       }
       const receipts = result.status === "completed" ? result.receipts : [];
-      const actions = receipts.map(item => ({ id: item.id, ownerService: item.ownerService,
-        objectId: item.objectId, kind: item.kind, lifecycleState: item.lifecycleState,
-        evidenceRefs: item.evidenceRefs.map(ref => ({ resourceType: ref.resourceType, id: ref.id })) }));
-      const attention = receipts.some(item => ![ReceiptLifecycleState.SUCCEEDED, ReceiptLifecycleState.VERIFIED].includes(item.lifecycleState));
+      const actions = receipts.map(item => ({ id: item.id, ownerService: undefined,
+        objectId: undefined, kind: item.kind, lifecycleState: item.state,
+        evidenceRefs: item.evidence.map(ref => ({ resourceType: ref.kind, id: ref.id })) }));
+      const attention = receipts.some(item => ![ReceiptLifecycleState.SUCCEEDED, ReceiptLifecycleState.VERIFIED].includes(item.state));
       console.log(JSON.stringify({ status: result.status, turnId: result.turnId,
         reason: result.reason, body: result.status === "completed" && !structured ? result.body : undefined,
         brief, receiptIds: receipts.map(item => item.id), actions,
         actionStatus: !actions.length ? "not_reported" : attention ? "requires_attention" : "owner_reported_success",
-        requestId: result.event?.requestId, requestType: result.event?.requestType, errorCode: result.turn?.errorCode,
+        requestId: result.event?.requestId, requestKind: result.event?.requestKind, errorCode: result.turn?.terminalError?.code,
       }));
       return result.status === "completed" && !attention ? 0 : 2;
     }

sdk/deixic/typescript/package.json

@@ -29,7 +29,7 @@
     "package.json"
   ],
   "scripts": {
-    "build": "node ../../maestro/typescript/scripts/verify-descriptor-sources.mjs && rm -rf dist && tsc -p tsconfig.json",
+    "build": "rm -rf dist && tsc -p tsconfig.json",
     "typecheck": "tsc --noEmit",
     "test": "npm run build && node --test test/*.test.mjs",
     "check:package": "npm run build && node scripts/check-package-exports.mjs && node scripts/smoke-packed-package.mjs",

sdk/deixic/typescript/scripts/smoke-packed-package.mjs

@@ -16,9 +16,9 @@ try {
   const names = new Set(result[0].files.map((file) => file.path));
   assert(names.has("LICENSE"));
   assert(names.has("dist/sdk/deixic/typescript/src/index.js"));
-  assert(names.has("dist/sdk/maestro/typescript/src/client.js"));
-  assert(names.has("dist/gen/ts/console/v1/console_pb.js"));
-  assert(names.has("dist/gen/ts/deixic/v1/deixic_pb.js"));
+  assert(names.has("dist/sdk/deixic/typescript/src/client.js"));
+  assert(names.has("dist/sdk/deixic/typescript/src/protocol.js"));
+  assert(![...names].some(name => name.includes("dist/gen/")));
   assert(names.has("examples/account-brief.mjs"));
   assert(names.has("dist/sdk/deixic/typescript/src/tasks.js"));
 
@@ -60,23 +60,23 @@ const client = createDeixicClient({
   transport: {
     async unary(method, signal, timeout, headers, input) {
       calls += 1;
-      assert.equal(method.parent.typeName, "deixic.v1.DeixicService");
+      assert.equal(method.parent.typeName, "deixicpublic.v1.DeixicPublicService");
       assert.equal(headers.get("Authorization"), "Bearer package-test-key");
-      assert.equal(input.query.organizationId, "org-package-test");
-      assert.equal(input.query.workspaceId, "workspace-package-test");
+      assert.equal(input.scope.organizationId, "org-package-test");
+      assert.equal(input.scope.workspaceId, "workspace-package-test");
       let fields;
-      if (method.name === "SubmitOperatingMessage") {
+      if (method.name === "SubmitTask") {
         assert.equal(input.idempotencyKey, "installed-request");
-        fields = { replayCursor: 9007199254740993n, acceptedTurn: { turnId: "installed-turn", sequence: 2n, state: OperatingTurnState.QUEUED } };
-      } else if (method.name === "ListOperatingThreadEvents") {
+        fields = { replayCursor: 9007199254740993n, acceptedTurn: { turnId: "installed-turn", sequence: 2n, state: OperatingTurnState.ACCEPTED } };
+      } else if (method.name === "ListEvents") {
         completed = true;
         fields = { nextCursor: input.afterCursor };
       } else {
-        assert.equal(method.name, "GetOperatingThread");
-        fields = { replayCursor: 9007199254740993n, channel: { id: "channel-package-test" },
-          turns: [{ turnId: "installed-turn", sequence: 2n, state: completed ? OperatingTurnState.COMPLETED : OperatingTurnState.QUEUED,
+        assert.equal(method.name, "GetThread");
+        fields = { replayCursor: 9007199254740993n, thread: { id: "channel-package-test" },
+          turns: [{ turnId: "installed-turn", sequence: 2n, state: completed ? OperatingTurnState.COMPLETED : OperatingTurnState.ACCEPTED,
             assistantMessageId: completed ? "answer" : "" }],
-          messages: completed ? [{ id: "answer", channelId: "channel-package-test", role: "assistant", body: "Installed result" }] : [] };
+          messages: completed ? [{ id: "answer", channelId: "channel-package-test", role: 2, body: "Installed result" }] : [] };
       }
       return { message: create(method.output, fields) };
     },