@stigmer/sdk 3.5.3 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/sdk",
-  "version": "3.5.3",
+  "version": "3.7.0",
   "description": "Stigmer TypeScript SDK — typed API client for all Stigmer platform resources",
   "license": "Apache-2.0",
   "type": "module",
@@ -45,6 +45,6 @@
   "peerDependencies": {
     "@bufbuild/protobuf": "^2.0.0",
     "@connectrpc/connect-node": "^2.0.0",
-    "@stigmer/protos": "3.5.3"
+    "@stigmer/protos": "3.7.0"
   }
 }

package/src/__tests__/manifest.test.ts

@@ -1,11 +1,14 @@
 import { describe, it, expect } from "vitest";
-import { create, equals } from "@bufbuild/protobuf";
+import { clone, create, equals } from "@bufbuild/protobuf";
 import { AgentSchema, type Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import { EnvironmentSchema, type Environment } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
+import { ScheduleSchema, type Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 import { parse as parseYaml } from "yaml";
 import { parseManifest } from "../manifest/parse";
 import { serializeManifest } from "../manifest/serialize";
+import { manifestDocumentForResource } from "../manifest/document";
 import { manifestKinds, manifestHandlerForYamlKind } from "../manifest/registry";
 
 /**
@@ -245,6 +248,80 @@ describe("serializeManifest", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// manifestDocumentForResource
+// ---------------------------------------------------------------------------
+
+describe("manifestDocumentForResource", () => {
+  // Shaped like a server-returned schedule: full metadata (including
+  // fields the curated ScheduleInput cannot express, like tags) and a
+  // populated status — the exact input of a lossless partial edit.
+  const schedule = create(ScheduleSchema, {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Schedule",
+    metadata: {
+      id: "sch_01example",
+      name: "daily-fee-reminders",
+      slug: "daily-fee-reminders",
+      org: "isc",
+      tags: ["billing"],
+      labels: { team: "ops" },
+    },
+    spec: {
+      cron: "0 9 * * *",
+      timeZone: "Asia/Kolkata",
+      enabled: true,
+      target: {
+        case: "agent",
+        value: {
+          agentRef: { kind: ApiResourceKind.agent, org: "isc", slug: "fee-reminder" },
+          message: "Send today's fee reminders.",
+        },
+      },
+    },
+    status: { consecutiveFailures: 2, pausedReason: "" },
+  });
+
+  it("wraps a fetched proto untouched — the lossless edit contract", () => {
+    const flipped = clone(ScheduleSchema, schedule);
+    flipped.spec!.enabled = false;
+
+    const doc = manifestDocumentForResource(flipped);
+
+    expect(doc.handler.yamlKind).toBe("Schedule");
+    expect(doc.name).toBe("daily-fee-reminders");
+    expect(doc.slug).toBe("daily-fee-reminders");
+    expect(doc.org).toBe("isc");
+    // Identity, not a copy: nothing is re-serialized or down-converted,
+    // so every field survives (the ScheduleInput path would drop tags).
+    expect(doc.message).toBe(flipped);
+
+    const expected = clone(ScheduleSchema, schedule);
+    expected.spec!.enabled = false;
+    expect(equals(ScheduleSchema, doc.message as Schedule, expected)).toBe(true);
+  });
+
+  it("falls back to name when the proto has no slug", () => {
+    const bare = create(AgentSchema, { metadata: { name: "x", org: "acme" } });
+    const doc = manifestDocumentForResource(bare);
+    expect(doc.slug).toBe("x");
+  });
+
+  it("rejects messages of kinds outside the registry", () => {
+    const notAResource = create(ApiResourceMetadataSchema, { name: "x" });
+    expect(() => manifestDocumentForResource(notAResource)).toThrow(
+      /not.*registry/i,
+    );
+  });
+
+  it("rejects a resource without metadata.name", () => {
+    const nameless = create(ScheduleSchema, { metadata: { org: "acme" } });
+    expect(() => manifestDocumentForResource(nameless)).toThrow(
+      /metadata\.name/,
+    );
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Registry invariants
 // ---------------------------------------------------------------------------

package/src/gen/agentchannel.ts

@@ -7,9 +7,12 @@ import { create } from "@bufbuild/protobuf";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
 import { AgentChannelSchema, type AgentChannel } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
 import { AgentChannelCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/command_pb";
+import { ChannelConversationCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/conversation_command_pb";
+import { ReplyToConversationInputSchema, ConversationControlInputSchema, ChannelConversationSchema, EscalateConversationInputSchema, ListChannelConversationsInputSchema, ChannelConversationListSchema, GetConversationTimelineInputSchema, ConversationTimelineSchema, type ReplyToConversationInput, type ConversationControlInput, type ChannelConversation, type EscalateConversationInput, type ListChannelConversationsInput, type ChannelConversationList, type GetConversationTimelineInput, type ConversationTimeline } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/conversation_io_pb";
+import { ChannelConversationQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/conversation_query_pb";
 import { AgentChannelIdSchema, InitiateChannelInstallInputSchema, InitiateChannelInstallOutputSchema, CompleteChannelInstallInputSchema, GetAgentChannelsByAgentRequestSchema, AgentChannelListSchema, ListAgentChannelsRequestSchema, type InitiateChannelInstallInput, type InitiateChannelInstallOutput, type CompleteChannelInstallInput, type GetAgentChannelsByAgentRequest, type AgentChannelList, type ListAgentChannelsRequest } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/io_pb";
 import { ChannelMessageCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/message_command_pb";
-import { SendChannelMessageInputSchema, SendChannelMessageOutputSchema, ListChannelTemplatesInputSchema, ChannelTemplatesSchema, type SendChannelMessageInput, type SendChannelMessageOutput, type ListChannelTemplatesInput, type ChannelTemplates } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/message_io_pb";
+import { SendChannelMessageOutputSchema, SendChannelMessageInputSchema, ListChannelTemplatesInputSchema, ChannelTemplatesSchema, ListMessagingChannelsInputSchema, MessagingChannelsSchema, type SendChannelMessageOutput, type SendChannelMessageInput, type ListChannelTemplatesInput, type ChannelTemplates, type ListMessagingChannelsInput, type MessagingChannels } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/message_io_pb";
 import { ChannelMessageQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/message_query_pb";
 import { AgentChannelQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/query_pb";
 import { AgentChannelSpecSchema, SlackChannelConfigSchema, WhatsAppChannelConfigSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/spec_pb";
@@ -21,12 +24,16 @@ import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/ap
 /** Provides operations on agentchannel resources. */
 export class AgentChannelClient {
   private readonly command: Client<typeof AgentChannelCommandController>;
+  private readonly channelConversationCommand: Client<typeof ChannelConversationCommandController>;
+  private readonly channelConversationQuery: Client<typeof ChannelConversationQueryController>;
   private readonly channelMessageCommand: Client<typeof ChannelMessageCommandController>;
   private readonly channelMessageQuery: Client<typeof ChannelMessageQueryController>;
   private readonly query: Client<typeof AgentChannelQueryController>;
 
   constructor(transport: Transport) {
     this.command = createClient(AgentChannelCommandController, transport);
+    this.channelConversationCommand = createClient(ChannelConversationCommandController, transport);
+    this.channelConversationQuery = createClient(ChannelConversationQueryController, transport);
     this.channelMessageCommand = createClient(ChannelMessageCommandController, transport);
     this.channelMessageQuery = createClient(ChannelMessageQueryController, transport);
     this.query = createClient(AgentChannelQueryController, transport);
@@ -68,6 +75,48 @@ export class AgentChannelClient {
     } catch (e) { throw wrapError(e); }
   }
 
+  async reply(input: ReplyToConversationInput): Promise<SendChannelMessageOutput> {
+    try {
+      return await this.channelConversationCommand.reply(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async takeOver(input: ConversationControlInput): Promise<ChannelConversation> {
+    try {
+      return await this.channelConversationCommand.takeOver(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async handBack(input: ConversationControlInput): Promise<ChannelConversation> {
+    try {
+      return await this.channelConversationCommand.handBack(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async clearAttention(input: ConversationControlInput): Promise<ChannelConversation> {
+    try {
+      return await this.channelConversationCommand.clearAttention(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async escalate(input: EscalateConversationInput): Promise<ChannelConversation> {
+    try {
+      return await this.channelConversationCommand.escalate(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async listConversations(input: ListChannelConversationsInput): Promise<ChannelConversationList> {
+    try {
+      return await this.channelConversationQuery.listConversations(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async getTimeline(input: GetConversationTimelineInput): Promise<ConversationTimeline> {
+    try {
+      return await this.channelConversationQuery.getTimeline(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
   async sendMessage(input: SendChannelMessageInput): Promise<SendChannelMessageOutput> {
     try {
       return await this.channelMessageCommand.sendMessage(input);
@@ -80,6 +129,12 @@ export class AgentChannelClient {
     } catch (e) { throw wrapError(e); }
   }
 
+  async listMessagingChannels(input: ListMessagingChannelsInput): Promise<MessagingChannels> {
+    try {
+      return await this.channelMessageQuery.listMessagingChannels(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
   async get(id: string): Promise<AgentChannel> {
     try {
       return await this.query.get(create(AgentChannelIdSchema, { value: id }));

package/src/gen/agentexecution.ts

@@ -8,7 +8,7 @@ import { createClient, type Client, type Transport } from "@connectrpc/connect";
 import { ToolApprovalOverrideSchema, McpServerUsageSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
 import { AgentExecutionSchema, type AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { AgentExecutionCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/command_pb";
-import { InteractionMode, ApprovalMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { InteractionMode, ApprovalMode, ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { AgentExecutionIdSchema, AgentExecutionUpdateStatusInputSchema, UpdateStatusResponseSchema, SubmitApprovalInputSchema, SubmitFileDecisionInputSchema, CancelAgentExecutionInputSchema, TerminateAgentExecutionInputSchema, RecoverAgentExecutionInputSchema, PauseAgentExecutionInputSchema, ResumeAgentExecutionInputSchema, UploadAttachmentRequestSchema, UploadAttachmentResponseSchema, ListAgentExecutionsRequestSchema, AgentExecutionListSchema, ListAgentExecutionsBySessionRequestSchema, GetArtifactDownloadUrlRequestSchema, GetArtifactDownloadUrlResponseSchema, GetArtifactContentRequestSchema, GetArtifactContentResponseSchema, GetExecutionUsageReportInputSchema, GetExecutionUsageReportOutputSchema, GetSessionUsageReportInputSchema, GetSessionUsageReportOutputSchema, GetAgentUsageReportInputSchema, GetAgentUsageReportOutputSchema, GetOrgUsageReportInputSchema, GetOrgUsageReportOutputSchema, GetAgentExecutionSummaryRequestSchema, AgentExecutionSummarySchema, type AgentExecutionUpdateStatusInput, type UpdateStatusResponse, type SubmitApprovalInput, type SubmitFileDecisionInput, type CancelAgentExecutionInput, type TerminateAgentExecutionInput, type RecoverAgentExecutionInput, type PauseAgentExecutionInput, type ResumeAgentExecutionInput, type UploadAttachmentRequest, type UploadAttachmentResponse, type ListAgentExecutionsRequest, type AgentExecutionList, type ListAgentExecutionsBySessionRequest, type GetArtifactDownloadUrlRequest, type GetArtifactDownloadUrlResponse, type GetArtifactContentRequest, type GetArtifactContentResponse, type GetExecutionUsageReportInput, type GetExecutionUsageReportOutput, type GetSessionUsageReportInput, type GetSessionUsageReportOutput, type GetAgentUsageReportInput, type GetAgentUsageReportOutput, type GetOrgUsageReportInput, type GetOrgUsageReportOutput, type GetAgentExecutionSummaryRequest, type AgentExecutionSummary } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
 import { AgentExecutionQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/query_pb";
 import { AgentExecutionSpecSchema, ContextManagementConfigSchema, ExecutionConfigSchema, AttachmentSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
@@ -259,6 +259,7 @@ export interface ExecutionConfigInput {
   structuredOutputSchema?: JsonObject;
   buildFromPlan?: boolean;
   approvalMode?: ApprovalMode;
+  serviceTier?: ServiceTier;
 }
 
 /** SDK input type for ContextManagementConfig. */
@@ -362,6 +363,7 @@ function buildExecutionConfigProto(input: ExecutionConfigInput) {
   if (input.structuredOutputSchema !== undefined) msg.structuredOutputSchema = input.structuredOutputSchema;
   if (input.buildFromPlan !== undefined) msg.buildFromPlan = input.buildFromPlan;
   if (input.approvalMode !== undefined) msg.approvalMode = input.approvalMode;
+  if (input.serviceTier !== undefined) msg.serviceTier = input.serviceTier;
   return msg;
 }
 

package/src/gen/authorization-config.ts

@@ -24,7 +24,7 @@ export const GRANTABLE_ROLES: ReadonlyMap<ApiResourceKind, readonly IamRole[]> =
   [ApiResourceKind.mcp_server, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.agent_instance, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.agent_share, [IamRole.owner, IamRole.viewer]],
-  [ApiResourceKind.agent_channel, [IamRole.owner, IamRole.viewer]],
+  [ApiResourceKind.agent_channel, [IamRole.owner, IamRole.viewer, IamRole.participant]],
   [ApiResourceKind.channel_app, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.datastore, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.workflow, [IamRole.owner, IamRole.viewer]],
@@ -32,5 +32,6 @@ export const GRANTABLE_ROLES: ReadonlyMap<ApiResourceKind, readonly IamRole[]> =
   [ApiResourceKind.workflow_execution, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.environment, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.artifact, [IamRole.owner, IamRole.viewer]],
+  [ApiResourceKind.schedule, [IamRole.owner, IamRole.viewer]],
   [ApiResourceKind.project, [IamRole.owner, IamRole.viewer]],
 ]);

package/src/gen/client.ts

@@ -21,6 +21,7 @@ import { OAuthAppClient } from "./oauthapp.js";
 import { OrganizationClient } from "./organization.js";
 import { PlatformClientClient } from "./platformclient.js";
 import { ProjectClient } from "./project.js";
+import { ScheduleClient } from "./schedule.js";
 import { SessionClient } from "./session.js";
 import { SkillClient } from "./skill.js";
 import { WorkflowClient } from "./workflow.js";
@@ -49,6 +50,7 @@ export class GeneratedClient {
   readonly organization: OrganizationClient;
   readonly platformclient: PlatformClientClient;
   readonly project: ProjectClient;
+  readonly schedule: ScheduleClient;
   readonly session: SessionClient;
   readonly skill: SkillClient;
   readonly workflow: WorkflowClient;
@@ -76,6 +78,7 @@ export class GeneratedClient {
     this.organization = new OrganizationClient(transport);
     this.platformclient = new PlatformClientClient(transport);
     this.project = new ProjectClient(transport);
+    this.schedule = new ScheduleClient(transport);
     this.session = new SessionClient(transport);
     this.skill = new SkillClient(transport);
     this.workflow = new WorkflowClient(transport);
@@ -125,6 +128,8 @@ export { PlatformClientClient } from "./platformclient.js";
 export { type PlatformClientInput } from "./platformclient.js";
 export { ProjectClient } from "./project.js";
 export { type ProjectInput } from "./project.js";
+export { ScheduleClient } from "./schedule.js";
+export { type ScheduleInput, type AgentInvocationInput, type RunConfigInput } from "./schedule.js";
 export { SessionClient } from "./session.js";
 export { type SessionInput } from "./session.js";
 export { SkillClient } from "./skill.js";

package/src/gen/schedule.ts

@@ -0,0 +1,230 @@
+// Code generated by stigmer-codegen. DO NOT EDIT.
+
+import { wrapError } from "./errors.js";
+import { stripUndefined } from "./proto-utils.js";
+import { type ResourceRef } from "./types.js";
+import { create } from "@bufbuild/protobuf";
+import { createClient, type Client, type Transport } from "@connectrpc/connect";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { RunConfigSchema, AgentInvocationSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/invocation_pb";
+import { ScheduleSchema, type Schedule } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+import { ScheduleCommandController } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/command_pb";
+import { ScheduleIdSchema, ScheduleTriggerResultSchema, GetSchedulesByAgentRequestSchema, ScheduleListSchema, ListSchedulesRequestSchema, ListScheduleRunsRequestSchema, ScheduleRunListSchema, type ScheduleTriggerResult, type GetSchedulesByAgentRequest, type ScheduleList, type ListSchedulesRequest, type ListScheduleRunsRequest, type ScheduleRunList } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
+import { ScheduleQueryController } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/query_pb";
+import { ScheduleSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/spec_pb";
+import { Harness, GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { GitRepoSourceSchema, LocalPathSourceSchema, WorkspaceSourceSchema, WorkspaceEntrySchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
+import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
+import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
+
+/** Provides operations on schedule resources. */
+export class ScheduleClient {
+  private readonly command: Client<typeof ScheduleCommandController>;
+  private readonly query: Client<typeof ScheduleQueryController>;
+
+  constructor(transport: Transport) {
+    this.command = createClient(ScheduleCommandController, transport);
+    this.query = createClient(ScheduleQueryController, transport);
+  }
+
+  async apply(input: ScheduleInput): Promise<Schedule> {
+    try {
+      return await this.command.apply(buildScheduleProto(input));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async create(input: ScheduleInput): Promise<Schedule> {
+    try {
+      return await this.command.create(buildScheduleProto(input));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async update(input: ScheduleInput): Promise<Schedule> {
+    try {
+      return await this.command.update(buildScheduleProto(input));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async delete(id: string): Promise<Schedule> {
+    try {
+      return await this.command.delete(create(ScheduleIdSchema, { value: id }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async resume(id: string): Promise<Schedule> {
+    try {
+      return await this.command.resume(create(ScheduleIdSchema, { value: id }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async trigger(id: string): Promise<ScheduleTriggerResult> {
+    try {
+      return await this.command.trigger(create(ScheduleIdSchema, { value: id }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async get(id: string): Promise<Schedule> {
+    try {
+      return await this.query.get(create(ScheduleIdSchema, { value: id }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async getByReference(ref: ResourceRef): Promise<Schedule> {
+    try {
+      return await this.query.getByReference(create(ApiResourceReferenceSchema, { ...ref, kind: ApiResourceKind.schedule }));
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async getByAgent(input: GetSchedulesByAgentRequest): Promise<ScheduleList> {
+    try {
+      return await this.query.getByAgent(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async list(input: ListSchedulesRequest): Promise<ScheduleList> {
+    try {
+      return await this.query.list(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async listRuns(input: ListScheduleRunsRequest): Promise<ScheduleRunList> {
+    try {
+      return await this.query.listRuns(input);
+    } catch (e) { throw wrapError(e); }
+  }
+}
+
+/** Input for creating/updating a Schedule. */
+export interface ScheduleInput {
+  name: string;
+  slug?: string;
+  org: string;
+  labels?: Record<string, string>;
+  visibility?: ApiResourceVisibility;
+  cron?: string;
+  timeZone?: string;
+  enabled?: boolean;
+  agent?: AgentInvocationInput;
+}
+
+/** SDK input type for AgentInvocation. */
+export interface AgentInvocationInput {
+  agentRef: ResourceRef;
+  message?: string;
+  harness?: Harness;
+  workspaceEntries?: WorkspaceEntryInput[];
+  environmentRefs?: ResourceRef[];
+  runConfig?: RunConfigInput;
+}
+
+/** SDK input type for WorkspaceEntry. */
+export interface WorkspaceEntryInput {
+  name?: string;
+  source: WorkspaceSourceInput;
+}
+
+/** SDK input type for WorkspaceSource. */
+export interface WorkspaceSourceInput {
+  gitRepo?: GitRepoSourceInput;
+  localPath?: LocalPathSourceInput;
+}
+
+/** SDK input type for GitRepoSource. */
+export interface GitRepoSourceInput {
+  url: string;
+  branch?: string;
+  commit?: string;
+  depth?: number;
+  writeBackMode?: GitWriteBackMode;
+}
+
+/** SDK input type for LocalPathSource. */
+export interface LocalPathSourceInput {
+  path?: string;
+}
+
+/** SDK input type for RunConfig. */
+export interface RunConfigInput {
+  modelName?: string;
+  maxCostUsd?: number;
+  maxToolRounds?: number;
+  serviceTier?: ServiceTier;
+}
+
+function buildGitRepoSourceProto(input: GitRepoSourceInput) {
+  return Object.assign(create(GitRepoSourceSchema), stripUndefined({
+    url: input.url,
+    branch: input.branch,
+    commit: input.commit,
+    depth: input.depth,
+    writeBackMode: input.writeBackMode,
+  }));
+}
+
+function buildLocalPathSourceProto(input: LocalPathSourceInput) {
+  return Object.assign(create(LocalPathSourceSchema), stripUndefined({
+    path: input.path,
+  }));
+}
+
+function buildWorkspaceSourceProto(input: WorkspaceSourceInput) {
+  const msg = create(WorkspaceSourceSchema);
+  if (input.gitRepo) {
+    msg.source = { case: "gitRepo", value: buildGitRepoSourceProto(input.gitRepo) };
+  } else if (input.localPath) {
+    msg.source = { case: "localPath", value: buildLocalPathSourceProto(input.localPath) };
+  }
+  return msg;
+}
+
+function buildWorkspaceEntryProto(input: WorkspaceEntryInput) {
+  const msg = create(WorkspaceEntrySchema);
+  if (input.name !== undefined) msg.name = input.name;
+  if (input.source) msg.source = buildWorkspaceSourceProto(input.source);
+  return msg;
+}
+
+function buildRunConfigProto(input: RunConfigInput) {
+  return Object.assign(create(RunConfigSchema), stripUndefined({
+    modelName: input.modelName,
+    maxCostUsd: input.maxCostUsd,
+    maxToolRounds: input.maxToolRounds,
+    serviceTier: input.serviceTier,
+  }));
+}
+
+function buildAgentInvocationProto(input: AgentInvocationInput) {
+  const msg = create(AgentInvocationSchema);
+  if (input.agentRef?.slug || input.agentRef?.org) msg.agentRef = create(ApiResourceReferenceSchema, { ...input.agentRef, kind: 40 });
+  if (input.message !== undefined) msg.message = input.message;
+  if (input.harness !== undefined) msg.harness = input.harness;
+  if (input.workspaceEntries) msg.workspaceEntries = input.workspaceEntries.map(buildWorkspaceEntryProto);
+  if (input.environmentRefs) msg.environmentRefs = input.environmentRefs.map(r => create(ApiResourceReferenceSchema, { ...r, kind: 53 }));
+  if (input.runConfig) msg.runConfig = buildRunConfigProto(input.runConfig);
+  return msg;
+}
+
+export function buildScheduleProto(input: ScheduleInput): Schedule {
+  const spec = Object.assign(create(ScheduleSpecSchema), stripUndefined({
+    cron: input.cron,
+    timeZone: input.timeZone,
+    enabled: input.enabled,
+  }));
+  if (input.agent) {
+    spec.target = { case: "agent", value: buildAgentInvocationProto(input.agent) };
+  }
+  return Object.assign(create(ScheduleSchema), {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Schedule",
+    metadata: Object.assign(create(ApiResourceMetadataSchema), {
+      name: input.name,
+      org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
+      ...(input.visibility && { visibility: input.visibility }),
+    }),
+    spec,
+  }) as Schedule;
+}

package/src/iam-role.ts

@@ -6,6 +6,7 @@ const ROLE_STRINGS: Record<IamRole, string> = {
   [IamRole.admin]: "admin",
   [IamRole.member]: "member",
   [IamRole.viewer]: "viewer",
+  [IamRole.participant]: "participant",
 };
 
 const STRING_TO_ROLE: Record<string, IamRole> = {
@@ -13,6 +14,7 @@ const STRING_TO_ROLE: Record<string, IamRole> = {
   admin: IamRole.admin,
   member: IamRole.member,
   viewer: IamRole.viewer,
+  participant: IamRole.participant,
 };
 
 const ROLE_DISPLAY_NAMES: Record<IamRole, string> = {
@@ -21,6 +23,7 @@ const ROLE_DISPLAY_NAMES: Record<IamRole, string> = {
   [IamRole.admin]: "Admin",
   [IamRole.member]: "Member",
   [IamRole.viewer]: "Viewer",
+  [IamRole.participant]: "Participant",
 };
 
 const ROLE_DESCRIPTIONS: Record<IamRole, string> = {
@@ -29,6 +32,7 @@ const ROLE_DESCRIPTIONS: Record<IamRole, string> = {
   [IamRole.admin]: "Edit access and member management",
   [IamRole.member]: "Standard access to organization resources",
   [IamRole.viewer]: "Read-only access",
+  [IamRole.participant]: "Reply to customers and manage conversation takeover",
 };
 
 /**

package/src/index.ts

@@ -132,6 +132,7 @@ export {
   ManifestClient,
   parseManifest,
   serializeManifest,
+  manifestDocumentForResource,
   manifestKinds,
   manifestHandlerForYamlKind,
   manifestHandlerForTypeName,
@@ -240,6 +241,13 @@ export {
   type PlatformClientInput,
 } from "./gen/platformclient.js";
 export { ProjectClient, type ProjectInput } from "./gen/project.js";
+export {
+  ScheduleClient,
+  buildScheduleProto,
+  type ScheduleInput,
+  type AgentInvocationInput,
+  type RunConfigInput,
+} from "./gen/schedule.js";
 export {
   SessionClient,
   type SessionInput,

package/src/manifest/document.ts

@@ -0,0 +1,70 @@
+// Build a ManifestDocument directly from a live resource proto.
+//
+// The programmatic sibling of `parseManifest`: where parsing starts from
+// YAML text, this starts from a proto the server already returned (a
+// `get`/`getByReference` result). It exists for lossless partial edits —
+// clone the fetched proto, change one field, apply the whole thing — so
+// callers never have to down-convert a proto into a curated `*Input`
+// shape (which cannot express every metadata field and would silently
+// drop the ones it can't carry).
+
+import type { Message } from "@bufbuild/protobuf";
+import { metadataOf, type ManifestDocument } from "./parse.js";
+import { manifestHandlerForTypeName, manifestKinds } from "./registry.js";
+
+/**
+ * Wrap a resource proto as a {@link ManifestDocument} ready for
+ * `stigmer.manifest.apply()`.
+ *
+ * The resource kind is derived from the message's proto type, so any
+ * registry-supported resource works with the same call. The message is
+ * passed through untouched — full fidelity, no serialization round-trip.
+ * The server ignores client-provided `status` on apply, so a fetched
+ * proto (status included) is safe to send as-is.
+ *
+ * @param message - A resource proto of a registry-supported kind, with
+ *   `metadata.name` set (always true for server-returned resources).
+ * @returns A document ready for `ManifestClient.apply`.
+ * @throws {Error} When the message's kind is not in the manifest
+ *   registry, or the message has no `metadata.name`.
+ *
+ * @example
+ * ```ts
+ * import { clone } from "@bufbuild/protobuf";
+ * import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
+ *
+ * const schedule = await stigmer.schedule.getByReference({ org, slug });
+ * const updated = clone(ScheduleSchema, schedule);
+ * updated.spec!.enabled = false;
+ * await stigmer.manifest.apply(manifestDocumentForResource(updated));
+ * ```
+ */
+export function manifestDocumentForResource(message: Message): ManifestDocument {
+  const handler = manifestHandlerForTypeName(message.$typeName);
+  if (handler === undefined) {
+    const supported = manifestKinds()
+      .map((h) => h.yamlKind)
+      .join(", ");
+    throw new Error(
+      `Cannot apply ${message.$typeName} as a manifest: kind is not ` +
+        `in the manifest registry. Supported kinds: ${supported}.`,
+    );
+  }
+
+  const metadata = metadataOf(message);
+  const name = metadata?.name ?? "";
+  if (name === "") {
+    throw new Error(
+      `Cannot apply this ${handler.displayName}: metadata.name is empty. ` +
+        "Pass a resource as returned by the server (get/getByReference).",
+    );
+  }
+
+  return {
+    handler,
+    message,
+    name,
+    slug: metadata?.slug || name,
+    org: metadata?.org ?? "",
+  };
+}

package/src/manifest/index.ts

@@ -14,6 +14,8 @@ export type { ManifestKindHandler, ServiceClientFn } from "./registry.js";
 export { parseManifest, metadataOf } from "./parse.js";
 export type { ManifestDocument, ParseManifestOptions } from "./parse.js";
 
+export { manifestDocumentForResource } from "./document.js";
+
 export { serializeManifest } from "./serialize.js";
 
 export { ManifestClient } from "./client.js";