@opengeni/sdk 0.29.0 → 0.33.1

package/dist/workspace-artifacts.d.ts

@@ -0,0 +1,94 @@
+export type WorkspaceArtifactVersion = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    artifactId: string;
+    revision: number;
+    contentType: "text/html";
+    contentSha256: string;
+    sizeBytes: number;
+    sourceSessionId: string | null;
+    sourceTurnId: string | null;
+    sourceAttemptId: string | null;
+    sourceExecutionGeneration: number | null;
+    createdBySubjectId: string;
+    createdAt: string;
+};
+export type WorkspaceArtifact = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    slug: string;
+    title: string;
+    description: string | null;
+    status: "active" | "archived";
+    currentVersion: WorkspaceArtifactVersion | null;
+    createdBySubjectId: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type WorkspaceArtifactEvent = {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    artifactId: string;
+    type: "published" | "rolled_back";
+    fromVersionId: string | null;
+    toVersionId: string;
+    sourceSessionId: string | null;
+    sourceTurnId: string | null;
+    sourceAttemptId: string | null;
+    sourceExecutionGeneration: number | null;
+    actorSubjectId: string;
+    reason: string;
+    createdAt: string;
+};
+export type WorkspaceArtifactListOptions = {
+    limit?: number;
+    cursor?: string;
+};
+export type WorkspaceArtifactListResponse = {
+    artifacts: WorkspaceArtifact[];
+    nextCursor: string | null;
+    truncated: boolean;
+};
+export type WorkspaceArtifactDetailResponse = {
+    artifact: WorkspaceArtifact;
+    versions: WorkspaceArtifactVersion[];
+    events: WorkspaceArtifactEvent[];
+    versionsTruncated: boolean;
+    eventsTruncated: boolean;
+};
+export type WorkspaceArtifactContentResponse = {
+    artifactId: string;
+    versionId: string;
+    contentType: "text/html";
+    contentSha256: string;
+    html: string;
+};
+export type WorkspaceArtifactMutationResponse = {
+    artifact: WorkspaceArtifact;
+    version: WorkspaceArtifactVersion;
+    event: WorkspaceArtifactEvent;
+    replayed: boolean;
+};
+export type CreateWorkspaceArtifactRequest = {
+    slug?: string;
+    title: string;
+    description?: string | null;
+    html: string;
+    idempotencyKey: string;
+};
+export type PublishWorkspaceArtifactVersionRequest = {
+    title?: string;
+    description?: string | null;
+    html: string;
+    expectedCurrentVersionId: string;
+    idempotencyKey: string;
+};
+export type RollbackWorkspaceArtifactRequest = {
+    versionId: string;
+    expectedCurrentVersionId: string;
+    reason: string;
+    idempotencyKey: string;
+};

package/dist/workspace-control-stream.d.ts

@@ -0,0 +1,12 @@
+import type { StreamSessionEventsOptions } from "./stream";
+import type { WorkspaceControlEvent } from "./types";
+export type WorkspaceControlStreamTransport = {
+    /** The server replays every durable event after the cursor before going live. */
+    openStream: (after: number, signal: AbortSignal | undefined) => Promise<ReadableStream<Uint8Array>>;
+};
+/**
+ * Reconnecting workspace invalidation stream. Control revisions are monotonic
+ * but can begin above one after the one-way migration, so unlike conversation
+ * events this stream intentionally permits sparse sequence values.
+ */
+export declare function streamWorkspaceControlEvents(transport: WorkspaceControlStreamTransport, options?: StreamSessionEventsOptions): AsyncGenerator<WorkspaceControlEvent, void, void>;

package/dist/workspace-instruction-policies.d.ts

@@ -0,0 +1,98 @@
+export type WorkspaceInstructionPolicyKind = "charter" | "policy";
+export type WorkspaceInstructionPolicyScope = "global" | "role";
+export type WorkspaceInstructionPolicyProvenanceSource = "human" | "onboarding" | "knowledge_proposal" | "legacy_import";
+export type WorkspaceInstructionPolicyDraftProvenanceSource = Exclude<WorkspaceInstructionPolicyProvenanceSource, "legacy_import">;
+export type WorkspaceInstructionPolicyActivationType = "activate" | "rollback";
+export declare function normalizeWorkspaceInstructionPolicyRoleKey(value: string): string;
+export type WorkspaceInstructionPolicyTarget = {
+    kind: WorkspaceInstructionPolicyKind;
+    scope: WorkspaceInstructionPolicyScope;
+    roleKey: string | null;
+};
+export type WorkspaceInstructionPolicyRevisionIdentity = {
+    id: string;
+    revision: number;
+    contentHash: string;
+};
+export type WorkspaceInstructionPolicyRevision = WorkspaceInstructionPolicyRevisionIdentity & WorkspaceInstructionPolicyTarget & {
+    accountId: string;
+    workspaceId: string;
+    content: string;
+    provenance: {
+        source: WorkspaceInstructionPolicyProvenanceSource;
+        sourceId: string | null;
+    };
+    supersedesRevisionId: string | null;
+    createdBySubjectId: string;
+    createdAt: string;
+};
+export type WorkspaceInstructionPolicyHead = WorkspaceInstructionPolicyTarget & {
+    workspaceId: string;
+    revisionId: string;
+    revision: number;
+    contentHash: string;
+    activationVersion: number;
+    activatedAt: string;
+};
+export type WorkspaceInstructionPolicyActivationEvent = WorkspaceInstructionPolicyTarget & {
+    id: string;
+    accountId: string;
+    workspaceId: string;
+    type: WorkspaceInstructionPolicyActivationType;
+    activationVersion: number;
+    oldRevision: WorkspaceInstructionPolicyRevisionIdentity | null;
+    newRevision: WorkspaceInstructionPolicyRevisionIdentity;
+    actorSubjectId: string;
+    reason: string;
+    createdAt: string;
+};
+export type CreateWorkspaceInstructionPolicyDraftRequest = WorkspaceInstructionPolicyTarget & {
+    content: string;
+    provenanceSource?: WorkspaceInstructionPolicyDraftProvenanceSource;
+    provenanceSourceId?: string | null;
+    supersedesRevisionId?: string | null;
+};
+export type ImportLegacyWorkspaceInstructionPolicyDraftRequest = {
+    supersedesRevisionId?: string | null;
+};
+export type WorkspaceInstructionPolicyListOptions = {
+    kind?: WorkspaceInstructionPolicyKind;
+    scope?: WorkspaceInstructionPolicyScope;
+    roleKey?: string;
+    afterRevision?: number;
+    limit?: number;
+};
+export type WorkspaceInstructionPolicyListResponse = {
+    revisions: WorkspaceInstructionPolicyRevision[];
+    activeHeads: WorkspaceInstructionPolicyHead[];
+    activationEvents: WorkspaceInstructionPolicyActivationEvent[];
+    nextAfterRevision: number | null;
+};
+export type WorkspaceInstructionPolicyDiffRequest = {
+    fromRevisionId: string;
+    toRevisionId: string;
+};
+export type WorkspaceInstructionPolicyDiffResponse = {
+    from: WorkspaceInstructionPolicyRevision;
+    to: WorkspaceInstructionPolicyRevision;
+    format: "unified";
+    diff: string;
+};
+export type ActivateWorkspaceInstructionPolicyRequest = {
+    expectedCurrentRevisionId: string | null;
+    reason: string;
+};
+export type RollbackWorkspaceInstructionPolicyRequest = {
+    targetRevisionId: string;
+    expectedCurrentRevisionId: string;
+    reason: string;
+};
+export type WorkspaceInstructionPolicyActivationResponse = {
+    head: WorkspaceInstructionPolicyHead;
+    event: WorkspaceInstructionPolicyActivationEvent;
+};
+export type WorkspaceInstructionPolicyConflictResponse = {
+    code: "WORKSPACE_INSTRUCTION_POLICY_CONFLICT";
+    message: string;
+    currentHead: WorkspaceInstructionPolicyHead | null;
+};

package/dist/workspace-state.d.ts

@@ -0,0 +1,122 @@
+import type { WorkspaceInstructionPolicyKind, WorkspaceInstructionPolicyProvenanceSource, WorkspaceInstructionPolicyScope } from "./workspace-instruction-policies";
+export type WorkspaceStateDocumentStatusCounts = {
+    queued: number;
+    indexing: number;
+    ready: number;
+    failed: number;
+};
+export type WorkspaceStateSourceKindCounts = {
+    manual_upload: number;
+    meeting_transcript: number;
+    repository: number;
+    email: number;
+    chat: number;
+    document: number;
+    web: number;
+    other: number;
+};
+export type WorkspaceStateMemoryStatusCounts = {
+    proposed: number;
+    approved: number;
+    rejected: number;
+    active: number;
+    superseded: number;
+    archived: number;
+};
+export type WorkspaceStateMemoryKindCounts = {
+    semantic: number;
+    episodic: number;
+    procedural: number;
+    decision: number;
+    preference: number;
+};
+export type WorkspaceStateGapCode = "no_document_bases" | "no_visible_documents" | "failed_documents" | "processing_documents" | "missing_topic_coverage" | "no_memory_records" | "pending_memory_review" | "partial_inventory";
+export type WorkspaceStateResponse = {
+    workspaceId: string;
+    generatedAt: string;
+    truth: {
+        current: {
+            source: "read_time_projection";
+            capturedAt: string;
+        };
+        policySnapshot: {
+            status: "not_captured";
+            reason: "workspace_instruction_policy_snapshot_not_implemented";
+        };
+    };
+    policy: {
+        authority: "workspace_instruction_policy_heads";
+        activeHeads: Array<{
+            kind: WorkspaceInstructionPolicyKind;
+            scope: WorkspaceInstructionPolicyScope;
+            roleKey: string | null;
+            revisionId: string;
+            revision: number;
+            contentHash: string;
+            activationVersion: number;
+            activatedAt: string;
+        }>;
+        activeHeadsTruncated: boolean;
+        latestRevision: {
+            kind: WorkspaceInstructionPolicyKind;
+            scope: WorkspaceInstructionPolicyScope;
+            roleKey: string | null;
+            revisionId: string;
+            revision: number;
+            contentHash: string;
+            provenanceSource: WorkspaceInstructionPolicyProvenanceSource;
+            state: "active" | "inactive";
+            createdAt: string;
+        } | null;
+        legacyRuntime: {
+            source: "workspace_override" | "deployment_default";
+            workspaceOverrideConfigured: boolean;
+        };
+        runtimeComposition: {
+            status: "not_implemented";
+        };
+    };
+    knowledge: {
+        availability: "unavailable";
+        reason: "missing_permission";
+        requiredPermission: "documents:search";
+    } | {
+        availability: "available";
+        coverage: "complete" | "partial";
+        baseCount: number;
+        bases: Array<{
+            id: string;
+            name: string;
+            visibleDocumentCount: number;
+            statusCounts: WorkspaceStateDocumentStatusCounts;
+            latestUpdatedAt: string | null;
+        }>;
+        basesTruncated: boolean;
+        inspectedVisibleDocumentCount: number;
+        documentStatusCounts: WorkspaceStateDocumentStatusCounts;
+        sourceKindCounts: WorkspaceStateSourceKindCounts;
+        topics: Array<{
+            name: string;
+            documentCount: number;
+        }>;
+        topicsTruncated: boolean;
+        latestDocumentUpdatedAt: string | null;
+        memorySample: {
+            recordCount: number;
+            sampleLimit: 100;
+            limitReached: boolean;
+            statusCounts: WorkspaceStateMemoryStatusCounts;
+            kindCounts: WorkspaceStateMemoryKindCounts;
+            preferenceAuthority: {
+                kindCountSource: "knowledge_memories_legacy_observations";
+                activeAuthority: "structured_preference_registry";
+            };
+            latestUpdatedAt: string | null;
+        };
+        gaps: Array<{
+            code: WorkspaceStateGapCode;
+            severity: "info" | "warning";
+            relatedCount: number | null;
+        }>;
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/sdk",
-  "version": "0.29.0",
+  "version": "0.33.1",
   "description": "Framework-agnostic TypeScript SDK for the OpenGeni API: typed client, session lifecycle, SSE event streaming with reconnect + replay-by-sequence, and proxy re-streaming helpers.",
   "license": "Apache-2.0",
   "repository": {
@@ -21,6 +21,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.js"
     }
   },
   "publishConfig": {
@@ -28,8 +32,8 @@
     "provenance": true
   },
   "scripts": {
-    "typecheck": "tsgo --noEmit",
-    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "build": "bun ../../scripts/build-typescript-package.ts",
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
   "engines": {

package/src/artifact-client.ts

@@ -0,0 +1,85 @@
+import { OpenGeniClient as OpenGeniCoreClient } from "./client";
+import type {
+  CreateWorkspaceArtifactRequest,
+  PublishWorkspaceArtifactVersionRequest,
+  RollbackWorkspaceArtifactRequest,
+  WorkspaceArtifactContentResponse,
+  WorkspaceArtifactDetailResponse,
+  WorkspaceArtifactListOptions,
+  WorkspaceArtifactListResponse,
+  WorkspaceArtifactMutationResponse,
+} from "./workspace-artifacts";
+
+/** Public SDK client. Artifact operations stay out of the console's eager core graph. */
+export class OpenGeniClient extends OpenGeniCoreClient {
+  async listWorkspaceArtifacts(
+    workspaceId: string,
+    options: WorkspaceArtifactListOptions = {},
+  ): Promise<WorkspaceArtifactListResponse> {
+    const query = new URLSearchParams();
+    if (options.limit !== undefined) query.set("limit", String(options.limit));
+    if (options.cursor) query.set("cursor", options.cursor);
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    return await this.requestJson<WorkspaceArtifactListResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/published-artifacts${suffix}`,
+    );
+  }
+
+  async getWorkspaceArtifact(
+    workspaceId: string,
+    artifactId: string,
+  ): Promise<WorkspaceArtifactDetailResponse> {
+    return await this.requestJson<WorkspaceArtifactDetailResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/published-artifacts/${encodeURIComponent(artifactId)}`,
+    );
+  }
+
+  async getWorkspaceArtifactContent(
+    workspaceId: string,
+    artifactId: string,
+    versionId?: string,
+  ): Promise<WorkspaceArtifactContentResponse> {
+    const query = versionId ? `?versionId=${encodeURIComponent(versionId)}` : "";
+    return await this.requestJson<WorkspaceArtifactContentResponse>(
+      "GET",
+      `/v1/workspaces/${workspaceId}/published-artifacts/${encodeURIComponent(artifactId)}/content${query}`,
+    );
+  }
+
+  async createWorkspaceArtifact(
+    workspaceId: string,
+    request: CreateWorkspaceArtifactRequest,
+  ): Promise<WorkspaceArtifactMutationResponse> {
+    return await this.requestJson<WorkspaceArtifactMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/published-artifacts`,
+      request,
+    );
+  }
+
+  async publishWorkspaceArtifactVersion(
+    workspaceId: string,
+    artifactId: string,
+    request: PublishWorkspaceArtifactVersionRequest,
+  ): Promise<WorkspaceArtifactMutationResponse> {
+    return await this.requestJson<WorkspaceArtifactMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/published-artifacts/${encodeURIComponent(artifactId)}/versions`,
+      request,
+    );
+  }
+
+  async rollbackWorkspaceArtifact(
+    workspaceId: string,
+    artifactId: string,
+    request: RollbackWorkspaceArtifactRequest,
+  ): Promise<WorkspaceArtifactMutationResponse> {
+    return await this.requestJson<WorkspaceArtifactMutationResponse>(
+      "POST",
+      `/v1/workspaces/${workspaceId}/published-artifacts/${encodeURIComponent(artifactId)}/rollback`,
+      request,
+    );
+  }
+}