@stigmer/sdk 0.0.36 → 0.0.39

package/src/__tests__/gen/session-client.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import type { Transport } from "@connectrpc/connect";
+import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { SessionClient, type SessionInput } from "../../gen/session";
+
+interface CapturedRequest {
+  methodName: string;
+  message: unknown;
+}
+
+function createCapturingTransport(): {
+  transport: Transport;
+  captured: CapturedRequest[];
+} {
+  const captured: CapturedRequest[] = [];
+
+  const transport = {
+    unary: async (
+      method: { name: string },
+      _signal: unknown,
+      _timeout: unknown,
+      _header: unknown,
+      message: unknown,
+    ) => ({
+      header: new Headers(),
+      trailer: new Headers(),
+      message,
+    }),
+    stream: async () => {
+      throw new Error("streaming not implemented in test transport");
+    },
+  } as unknown as Transport;
+
+  const originalUnary = (transport as unknown as Record<string, unknown>).unary as (
+    ...args: unknown[]
+  ) => Promise<unknown>;
+
+  (transport as unknown as Record<string, unknown>).unary = async (
+    method: { name: string },
+    signal: unknown,
+    timeout: unknown,
+    header: unknown,
+    message: unknown,
+    ...rest: unknown[]
+  ) => {
+    captured.push({ methodName: method.name, message });
+    return originalUnary(method, signal, timeout, header, message, ...rest);
+  };
+
+  return { transport, captured };
+}
+
+describe("SessionClient proto serialization", () => {
+  let client: SessionClient;
+  let captured: CapturedRequest[];
+
+  beforeEach(() => {
+    const ctx = createCapturingTransport();
+    client = new SessionClient(ctx.transport);
+    captured = ctx.captured;
+  });
+
+  it("sets apiVersion and kind on the proto", async () => {
+    await client.create({ name: "test-session", org: "my-org" });
+
+    const proto = captured[0].message as Session;
+    expect(proto.apiVersion).toBe("agentic.stigmer.ai/v1");
+    expect(proto.kind).toBe("Session");
+  });
+
+  it("sets required fields on metadata", async () => {
+    await client.create({ name: "my-session", org: "acme" });
+
+    const proto = captured[0].message as Session;
+    expect(proto.metadata?.name).toBe("my-session");
+    expect(proto.metadata?.org).toBe("acme");
+  });
+
+  it("sets optional spec fields when provided", async () => {
+    const input: SessionInput = {
+      name: "s1",
+      org: "o1",
+      agentInstanceId: "ai-123",
+      subject: "Help with deployment",
+      threadId: "thread-abc",
+      sandboxId: "sandbox-xyz",
+    };
+
+    await client.create(input);
+
+    const proto = captured[0].message as Session;
+    expect(proto.spec?.agentInstanceId).toBe("ai-123");
+    expect(proto.spec?.subject).toBe("Help with deployment");
+    expect(proto.spec?.threadId).toBe("thread-abc");
+    expect(proto.spec?.sandboxId).toBe("sandbox-xyz");
+  });
+
+  it("does not overwrite protobuf defaults when optional fields are omitted", async () => {
+    await client.create({ name: "minimal", org: "org" });
+
+    const proto = captured[0].message as Session;
+    expect(proto.spec?.agentInstanceId).toBe("");
+    expect(proto.spec?.subject).toBe("");
+    expect(proto.spec?.threadId).toBe("");
+    expect(proto.spec?.sandboxId).toBe("");
+  });
+
+  it("serializes metadata map when provided", async () => {
+    await client.create({
+      name: "s1",
+      org: "o1",
+      metadata: { env: "production", region: "us-east-1" },
+    });
+
+    const proto = captured[0].message as Session;
+    expect(proto.spec?.metadata).toEqual({
+      env: "production",
+      region: "us-east-1",
+    });
+  });
+
+  it("serializes workspace entries with git repo source", async () => {
+    await client.create({
+      name: "s1",
+      org: "o1",
+      workspaceEntries: [
+        {
+          name: "my-repo",
+          source: {
+            gitRepo: {
+              url: "https://github.com/example/repo.git",
+              branch: "main",
+            },
+          },
+        },
+      ],
+    });
+
+    const proto = captured[0].message as Session;
+    const entries = proto.spec?.workspaceEntries;
+    expect(entries).toHaveLength(1);
+    expect(entries![0].name).toBe("my-repo");
+
+    const source = entries![0].source;
+    expect(source?.source?.case).toBe("gitRepo");
+    if (source?.source?.case === "gitRepo") {
+      expect(source.source.value.url).toBe(
+        "https://github.com/example/repo.git",
+      );
+      expect(source.source.value.branch).toBe("main");
+    }
+  });
+
+  it("serializes workspace entries with local path source", async () => {
+    await client.create({
+      name: "s1",
+      org: "o1",
+      workspaceEntries: [
+        {
+          name: "local",
+          source: {
+            localPath: { path: "/home/user/project" },
+          },
+        },
+      ],
+    });
+
+    const proto = captured[0].message as Session;
+    const entries = proto.spec?.workspaceEntries;
+    expect(entries).toHaveLength(1);
+
+    const source = entries![0].source;
+    expect(source?.source?.case).toBe("localPath");
+    if (source?.source?.case === "localPath") {
+      expect(source.source.value.path).toBe("/home/user/project");
+    }
+  });
+
+  it("routes create through the command controller", async () => {
+    await client.create({ name: "s1", org: "o1" });
+    expect(captured[0].methodName).toBe("create");
+  });
+
+  it("routes apply through the command controller", async () => {
+    await client.apply({ name: "s1", org: "o1" });
+    expect(captured[0].methodName).toBe("apply");
+  });
+
+  it("routes get through the query controller with SessionId", async () => {
+    await client.get("session-id-123");
+    const message = captured[0].message as { value: string };
+    expect(captured[0].methodName).toBe("get");
+    expect(message.value).toBe("session-id-123");
+  });
+
+  it("routes delete through the command controller with SessionId", async () => {
+    await client.delete("session-id-456");
+    const message = captured[0].message as { value: string };
+    expect(captured[0].methodName).toBe("delete");
+    expect(message.value).toBe("session-id-456");
+  });
+});

package/src/gen/agent.ts

@@ -1,14 +1,16 @@
 // Code generated by stigmer-codegen. DO NOT EDIT.
 
 import { wrapError } from "./errors";
+import { stripUndefined } from "./proto-utils";
 import { type ListParams, type ListResult, type EnvSpecInput, type ResourceRef } from "./types";
 import { create } from "@bufbuild/protobuf";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
 import { AgentSchema, type Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import { AgentCommandController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/command_pb";
-import { AgentIdSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/io_pb";
+import { AgentIdSchema, GetDefaultAgentRequestSchema, type GetDefaultAgentRequest } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/io_pb";
 import { AgentQueryController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/query_pb";
-import { AgentSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
+import { AgentSpecSchema, ToolApprovalOverrideSchema, McpServerUsageSchema, McpAccessSchema, SubAgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
+import { EnvironmentSpecSchema, EnvironmentValueSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
@@ -64,6 +66,12 @@ export class AgentClient {
     } catch (e) { throw wrapError(e); }
   }
 
+  async getDefault(input: GetDefaultAgentRequest): Promise<Agent> {
+    try {
+      return await this.query.getDefault(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
   async list(params: ListParams): Promise<ListResult> {
     try {
       const resp = await this.search.search(create(SearchRequestSchema, {
@@ -85,7 +93,9 @@ export class AgentClient {
 /** Input for creating/updating a Agent. */
 export interface AgentInput {
   name: string;
+  slug?: string;
   org: string;
+  labels?: Record<string, string>;
   description?: string;
   iconUrl?: string;
   instructions?: string;
@@ -125,22 +135,69 @@ export interface McpAccessInput {
   enabledTools?: string[];
 }
 
+function buildToolApprovalOverrideProto(input: ToolApprovalOverrideInput) {
+  return Object.assign(create(ToolApprovalOverrideSchema), stripUndefined({
+    toolName: input.toolName,
+    requiresApproval: input.requiresApproval,
+    message: input.message,
+  }));
+}
+
+function buildMcpServerUsageProto(input: McpServerUsageInput) {
+  const msg = create(McpServerUsageSchema);
+  if (input.mcpServerRef) msg.mcpServerRef = create(ApiResourceReferenceSchema, input.mcpServerRef);
+  if (input.enabledTools) msg.enabledTools = input.enabledTools;
+  if (input.toolApprovalOverrides) msg.toolApprovalOverrides = input.toolApprovalOverrides.map(buildToolApprovalOverrideProto);
+  return msg;
+}
+
+function buildMcpAccessProto(input: McpAccessInput) {
+  return Object.assign(create(McpAccessSchema), stripUndefined({
+    mcpServer: input.mcpServer,
+    enabledTools: input.enabledTools,
+  }));
+}
+
+function buildSubAgentProto(input: SubAgentInput) {
+  const msg = create(SubAgentSchema);
+  if (input.name !== undefined) msg.name = input.name;
+  if (input.description !== undefined) msg.description = input.description;
+  if (input.instructions !== undefined) msg.instructions = input.instructions;
+  if (input.mcpAccess) msg.mcpAccess = input.mcpAccess.map(buildMcpAccessProto);
+  if (input.skillRefs) msg.skillRefs = input.skillRefs.map(r => create(ApiResourceReferenceSchema, r));
+  if (input.modelOverride !== undefined) msg.modelOverride = input.modelOverride;
+  return msg;
+}
+
 function buildAgentProto(input: AgentInput): Agent {
+  const mcpServerUsages = input.mcpServerUsages?.map(buildMcpServerUsageProto);
+  const skillRefs = input.skillRefs?.map(r => create(ApiResourceReferenceSchema, r));
+  const subAgents = input.subAgents?.map(buildSubAgentProto);
+  let envSpec;
+  if (input.envSpec) {
+    const es = create(EnvironmentSpecSchema);
+    for (const [k, v] of Object.entries(input.envSpec.variables)) {
+      es.data[k] = create(EnvironmentValueSchema, { value: v.value, isSecret: v.isSecret, description: v.description });
+    }
+    envSpec = es;
+  }
   return Object.assign(create(AgentSchema), {
     apiVersion: "agentic.stigmer.ai/v1",
     kind: "Agent",
     metadata: Object.assign(create(ApiResourceMetadataSchema), {
       name: input.name,
       org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
     }),
-    spec: Object.assign(create(AgentSpecSchema), {
+    spec: Object.assign(create(AgentSpecSchema), stripUndefined({
       description: input.description,
       iconUrl: input.iconUrl,
       instructions: input.instructions,
-      mcpServerUsages: input.mcpServerUsages,
-      skillRefs: input.skillRefs,
-      subAgents: input.subAgents,
-      envSpec: input.envSpec,
-    }),
+      mcpServerUsages,
+      skillRefs,
+      subAgents,
+      envSpec,
+    })),
   }) as Agent;
 }

package/src/gen/agentexecution.ts

@@ -1,14 +1,16 @@
 // Code generated by stigmer-codegen. DO NOT EDIT.
 
 import { wrapError } from "./errors";
+import { stripUndefined } from "./proto-utils";
 import { type EnvVarInput } from "./types";
 import { create } from "@bufbuild/protobuf";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
 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 { AgentExecutionIdSchema, AgentExecutionUpdateStatusInputSchema, SubmitApprovalInputSchema, CancelAgentExecutionInputSchema, TerminateAgentExecutionInputSchema, RecoverAgentExecutionInputSchema, PauseAgentExecutionInputSchema, ResumeAgentExecutionInputSchema, UploadAttachmentRequestSchema, UploadAttachmentResponseSchema, ListAgentExecutionsRequestSchema, AgentExecutionListSchema, ListAgentExecutionsBySessionRequestSchema, GetArtifactDownloadUrlRequestSchema, GetArtifactDownloadUrlResponseSchema, GetSessionUsageReportInputSchema, GetSessionUsageReportOutputSchema, GetAgentUsageReportInputSchema, GetAgentUsageReportOutputSchema, GetOrgUsageReportInputSchema, GetOrgUsageReportOutputSchema, type AgentExecutionUpdateStatusInput, type SubmitApprovalInput, 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 GetSessionUsageReportInput, type GetSessionUsageReportOutput, type GetAgentUsageReportInput, type GetAgentUsageReportOutput, type GetOrgUsageReportInput, type GetOrgUsageReportOutput } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
+import { AgentExecutionIdSchema, AgentExecutionUpdateStatusInputSchema, SubmitApprovalInputSchema, CancelAgentExecutionInputSchema, TerminateAgentExecutionInputSchema, RecoverAgentExecutionInputSchema, PauseAgentExecutionInputSchema, ResumeAgentExecutionInputSchema, UploadAttachmentRequestSchema, UploadAttachmentResponseSchema, ListAgentExecutionsRequestSchema, AgentExecutionListSchema, ListAgentExecutionsBySessionRequestSchema, GetArtifactDownloadUrlRequestSchema, GetArtifactDownloadUrlResponseSchema, GetArtifactContentRequestSchema, GetArtifactContentResponseSchema, GetSessionUsageReportInputSchema, GetSessionUsageReportOutputSchema, GetAgentUsageReportInputSchema, GetAgentUsageReportOutputSchema, GetOrgUsageReportInputSchema, GetOrgUsageReportOutputSchema, type AgentExecutionUpdateStatusInput, type SubmitApprovalInput, 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 GetSessionUsageReportInput, type GetSessionUsageReportOutput, type GetAgentUsageReportInput, type GetAgentUsageReportOutput, type GetOrgUsageReportInput, type GetOrgUsageReportOutput } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
 import { AgentExecutionQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/query_pb";
-import { AgentExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
+import { AgentExecutionSpecSchema, ContextManagementConfigSchema, ExecutionConfigSchema, AttachmentSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
+import { ExecutionValueSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
 import { ApiResourceIdSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 
@@ -120,6 +122,12 @@ export class AgentExecutionClient {
     } catch (e) { throw wrapError(e); }
   }
 
+  async getArtifactContent(input: GetArtifactContentRequest): Promise<GetArtifactContentResponse> {
+    try {
+      return await this.query.getArtifactContent(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
   async getSessionUsageReport(input: GetSessionUsageReportInput): Promise<GetSessionUsageReportOutput> {
     try {
       return await this.query.getSessionUsageReport(input);
@@ -142,7 +150,9 @@ export class AgentExecutionClient {
 /** Input for creating/updating a AgentExecution. */
 export interface AgentExecutionInput {
   name: string;
+  slug?: string;
   org: string;
+  labels?: Record<string, string>;
   sessionId?: string;
   agentId?: string;
   message?: string;
@@ -181,25 +191,63 @@ export interface AttachmentInput {
   localPath?: string;
 }
 
+function buildContextManagementConfigProto(input: ContextManagementConfigInput) {
+  return Object.assign(create(ContextManagementConfigSchema), stripUndefined({
+    disableSummarization: input.disableSummarization,
+    customTriggerThreshold: input.customTriggerThreshold,
+    customTargetTokens: input.customTargetTokens,
+  }));
+}
+
+function buildExecutionConfigProto(input: ExecutionConfigInput) {
+  const msg = create(ExecutionConfigSchema);
+  if (input.modelName !== undefined) msg.modelName = input.modelName;
+  if (input.contextManagement) msg.contextManagement = buildContextManagementConfigProto(input.contextManagement);
+  if (input.maxToolRounds !== undefined) msg.maxToolRounds = input.maxToolRounds;
+  if (input.maxToolResultChars !== undefined) msg.maxToolResultChars = input.maxToolResultChars;
+  if (input.maxCostUsd !== undefined) msg.maxCostUsd = input.maxCostUsd;
+  return msg;
+}
+
+function buildAttachmentProto(input: AttachmentInput) {
+  return Object.assign(create(AttachmentSchema), stripUndefined({
+    filename: input.filename,
+    storageKey: input.storageKey,
+    mountPath: input.mountPath,
+    contentType: input.contentType,
+    extract: input.extract,
+    localPath: input.localPath,
+  }));
+}
+
 function buildAgentExecutionProto(input: AgentExecutionInput): AgentExecution {
+  const executionConfig = input.executionConfig ? buildExecutionConfigProto(input.executionConfig) : undefined;
+  let runtimeEnv;
+  if (input.runtimeEnv) {
+    runtimeEnv = Object.fromEntries(Object.entries(input.runtimeEnv).map(([k, v]) =>
+      [k, create(ExecutionValueSchema, { value: v.value, isSecret: v.isSecret })]));
+  }
+  const attachments = input.attachments?.map(buildAttachmentProto);
   return Object.assign(create(AgentExecutionSchema), {
     apiVersion: "agentic.stigmer.ai/v1",
     kind: "AgentExecution",
     metadata: Object.assign(create(ApiResourceMetadataSchema), {
       name: input.name,
       org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
     }),
-    spec: Object.assign(create(AgentExecutionSpecSchema), {
+    spec: Object.assign(create(AgentExecutionSpecSchema), stripUndefined({
       sessionId: input.sessionId,
       agentId: input.agentId,
       message: input.message,
-      executionConfig: input.executionConfig,
-      runtimeEnv: input.runtimeEnv,
+      executionConfig,
+      runtimeEnv,
       callbackToken: input.callbackToken,
       autoApproveAll: input.autoApproveAll,
       parentWorkflowId: input.parentWorkflowId,
-      attachments: input.attachments,
+      attachments,
       workspaceFileRefs: input.workspaceFileRefs,
-    }),
+    })),
   }) as AgentExecution;
 }

package/src/gen/agentinstance.ts

@@ -1,12 +1,13 @@
 // Code generated by stigmer-codegen. DO NOT EDIT.
 
 import { wrapError } from "./errors";
+import { stripUndefined } from "./proto-utils";
 import { type ResourceRef } from "./types";
 import { create } from "@bufbuild/protobuf";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
 import { AgentInstanceSchema, type AgentInstance } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
 import { AgentInstanceCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/command_pb";
-import { AgentInstanceIdSchema, GetAgentInstancesByAgentRequestSchema, AgentInstanceListSchema, type GetAgentInstancesByAgentRequest, type AgentInstanceList } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/io_pb";
+import { AgentInstanceIdSchema, GetAgentInstancesByAgentRequestSchema, AgentInstanceListSchema, ListAgentInstancesRequestSchema, type GetAgentInstancesByAgentRequest, type AgentInstanceList, type ListAgentInstancesRequest } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/io_pb";
 import { AgentInstanceQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/query_pb";
 import { AgentInstanceSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/spec_pb";
 import { ApiResourceReferenceSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
@@ -63,29 +64,40 @@ export class AgentInstanceClient {
       return await this.query.getByReference(create(ApiResourceReferenceSchema, ref));
     } catch (e) { throw wrapError(e); }
   }
+
+  async list(input: ListAgentInstancesRequest): Promise<AgentInstanceList> {
+    try {
+      return await this.query.list(input);
+    } catch (e) { throw wrapError(e); }
+  }
 }
 
 /** Input for creating/updating a AgentInstance. */
 export interface AgentInstanceInput {
   name: string;
+  slug?: string;
   org: string;
+  labels?: Record<string, string>;
   agentId?: string;
   description?: string;
   environmentRefs?: ResourceRef[];
 }
 
 function buildAgentInstanceProto(input: AgentInstanceInput): AgentInstance {
+  const environmentRefs = input.environmentRefs?.map(r => create(ApiResourceReferenceSchema, r));
   return Object.assign(create(AgentInstanceSchema), {
     apiVersion: "agentic.stigmer.ai/v1",
     kind: "AgentInstance",
     metadata: Object.assign(create(ApiResourceMetadataSchema), {
       name: input.name,
       org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
     }),
-    spec: Object.assign(create(AgentInstanceSpecSchema), {
+    spec: Object.assign(create(AgentInstanceSpecSchema), stripUndefined({
       agentId: input.agentId,
       description: input.description,
-      environmentRefs: input.environmentRefs,
-    }),
+      environmentRefs,
+    })),
   }) as AgentInstance;
 }

package/src/gen/apikey.ts

@@ -1,6 +1,7 @@
 // Code generated by stigmer-codegen. DO NOT EDIT.
 
 import { wrapError } from "./errors";
+import { stripUndefined } from "./proto-utils";
 import { create } from "@bufbuild/protobuf";
 import { EmptySchema } from "@bufbuild/protobuf/wkt";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
@@ -61,7 +62,9 @@ export class ApiKeyClient {
 /** Input for creating/updating a ApiKey. */
 export interface ApiKeyInput {
   name: string;
+  slug?: string;
   org: string;
+  labels?: Record<string, string>;
   keyHash?: string;
   fingerprint?: string;
   expiresAt?: Date | string;
@@ -75,12 +78,14 @@ function buildApiKeyProto(input: ApiKeyInput): ApiKey {
     metadata: Object.assign(create(ApiResourceMetadataSchema), {
       name: input.name,
       org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
     }),
-    spec: Object.assign(create(ApiKeySpecSchema), {
+    spec: Object.assign(create(ApiKeySpecSchema), stripUndefined({
       keyHash: input.keyHash,
       fingerprint: input.fingerprint,
       expiresAt: input.expiresAt,
       neverExpires: input.neverExpires,
-    }),
+    })),
   }) as ApiKey;
 }

package/src/gen/environment.ts

@@ -1,13 +1,15 @@
 // Code generated by stigmer-codegen. DO NOT EDIT.
 
 import { wrapError } from "./errors";
+import { stripUndefined } from "./proto-utils";
 import { type DeleteResourceInput, type ResourceRef, type EnvVarInput } from "./types";
 import { create } from "@bufbuild/protobuf";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
 import { EnvironmentSchema, type Environment } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { EnvironmentCommandController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/command_pb";
+import { UpdateEnvironmentVariablesRequestSchema, RemoveEnvironmentVariablesRequestSchema, EnvironmentSecretValueInputSchema, ListEnvironmentsRequestSchema, EnvironmentListSchema, type UpdateEnvironmentVariablesRequest, type RemoveEnvironmentVariablesRequest, type EnvironmentSecretValueInput, type ListEnvironmentsRequest, type EnvironmentList } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/io_pb";
 import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/query_pb";
-import { EnvironmentSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb";
+import { EnvironmentValueSchema, EnvironmentSpecSchema, type EnvironmentValue } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/spec_pb";
 import { ApiResourceIdSchema, ApiResourceReferenceSchema, ApiResourceDeleteInputSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 
@@ -49,6 +51,18 @@ export class EnvironmentClient {
     } catch (e) { throw wrapError(e); }
   }
 
+  async updateVariables(input: UpdateEnvironmentVariablesRequest): Promise<Environment> {
+    try {
+      return await this.command.updateVariables(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async removeVariables(input: RemoveEnvironmentVariablesRequest): Promise<Environment> {
+    try {
+      return await this.command.removeVariables(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
   async get(id: string): Promise<Environment> {
     try {
       return await this.query.get(create(ApiResourceIdSchema, { value: id }));
@@ -60,27 +74,48 @@ export class EnvironmentClient {
       return await this.query.getByReference(create(ApiResourceReferenceSchema, ref));
     } catch (e) { throw wrapError(e); }
   }
+
+  async getSecretValue(input: EnvironmentSecretValueInput): Promise<EnvironmentValue> {
+    try {
+      return await this.query.getSecretValue(input);
+    } catch (e) { throw wrapError(e); }
+  }
+
+  async list(input: ListEnvironmentsRequest): Promise<EnvironmentList> {
+    try {
+      return await this.query.list(input);
+    } catch (e) { throw wrapError(e); }
+  }
 }
 
 /** Input for creating/updating a Environment. */
 export interface EnvironmentInput {
   name: string;
+  slug?: string;
   org: string;
+  labels?: Record<string, string>;
   description?: string;
   data?: Record<string, EnvVarInput>;
 }
 
 function buildEnvironmentProto(input: EnvironmentInput): Environment {
+  let data;
+  if (input.data) {
+    data = Object.fromEntries(Object.entries(input.data).map(([k, v]) =>
+      [k, create(EnvironmentValueSchema, { value: v.value, isSecret: v.isSecret, description: v.description })]));
+  }
   return Object.assign(create(EnvironmentSchema), {
     apiVersion: "agentic.stigmer.ai/v1",
     kind: "Environment",
     metadata: Object.assign(create(ApiResourceMetadataSchema), {
       name: input.name,
       org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
     }),
-    spec: Object.assign(create(EnvironmentSpecSchema), {
+    spec: Object.assign(create(EnvironmentSpecSchema), stripUndefined({
       description: input.description,
-      data: input.data,
-    }),
+      data,
+    })),
   }) as Environment;
 }

package/src/gen/executioncontext.ts

@@ -1,6 +1,7 @@
 // Code generated by stigmer-codegen. DO NOT EDIT.
 
 import { wrapError } from "./errors";
+import { stripUndefined } from "./proto-utils";
 import { type DeleteResourceInput, type ResourceRef, type EnvVarInput } from "./types";
 import { create } from "@bufbuild/protobuf";
 import { createClient, type Client, type Transport } from "@connectrpc/connect";
@@ -8,7 +9,7 @@ import { ExecutionContextSchema, type ExecutionContext } from "@stigmer/protos/a
 import { ExecutionContextCommandController } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/command_pb";
 import { ExecutionContextIdSchema, ExecutionContextExecutionIdInputSchema, type ExecutionContextExecutionIdInput } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/io_pb";
 import { ExecutionContextQueryController } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/query_pb";
-import { ExecutionContextSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
+import { ExecutionContextSpecSchema, ExecutionValueSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
 import { ApiResourceReferenceSchema, ApiResourceDeleteInputSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 
@@ -66,22 +67,31 @@ export class ExecutionContextClient {
 /** Input for creating/updating a ExecutionContext. */
 export interface ExecutionContextInput {
   name: string;
+  slug?: string;
   org: string;
+  labels?: Record<string, string>;
   executionId?: string;
   data?: Record<string, EnvVarInput>;
 }
 
 function buildExecutionContextProto(input: ExecutionContextInput): ExecutionContext {
+  let data;
+  if (input.data) {
+    data = Object.fromEntries(Object.entries(input.data).map(([k, v]) =>
+      [k, create(ExecutionValueSchema, { value: v.value, isSecret: v.isSecret })]));
+  }
   return Object.assign(create(ExecutionContextSchema), {
     apiVersion: "agentic.stigmer.ai/v1",
     kind: "ExecutionContext",
     metadata: Object.assign(create(ApiResourceMetadataSchema), {
       name: input.name,
       org: input.org,
+      ...(input.slug && { slug: input.slug }),
+      ...(input.labels && { labels: input.labels }),
     }),
-    spec: Object.assign(create(ExecutionContextSpecSchema), {
+    spec: Object.assign(create(ExecutionContextSpecSchema), stripUndefined({
       executionId: input.executionId,
-      data: input.data,
-    }),
+      data,
+    })),
   }) as ExecutionContext;
 }