@continuous-labs/sdk 0.0.8 → 0.0.9

package/src/models/start-world-request.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
+
+export type StartWorldRequest = {
+  /**
+   * Initial simulated time for the first Start, in RFC 3339 format. Omission uses 2024-01-01T00:00:00Z. Saved business dates remain unchanged. Later starts preserve the clock.
+   */
+  startTime?: Date | undefined;
+};
+
+/** @internal */
+export type StartWorldRequest$Outbound = {
+  start_time?: string | undefined;
+};
+
+/** @internal */
+export const StartWorldRequest$outboundSchema: z.ZodMiniType<
+  StartWorldRequest$Outbound,
+  StartWorldRequest
+> = z.pipe(
+  z.object({
+    startTime: z.optional(z.pipe(z.date(), z.transform(v => v.toISOString()))),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      startTime: "start_time",
+    });
+  }),
+);
+
+export function startWorldRequestToJSON(
+  startWorldRequest: StartWorldRequest,
+): string {
+  return JSON.stringify(
+    StartWorldRequest$outboundSchema.parse(startWorldRequest),
+  );
+}

package/src/models/step.ts

@@ -3,12 +3,35 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
+/**
+ * api for an API write or advance for a clock advance.
+ */
+export const Kind = {
+  Api: "api",
+  Advance: "advance",
+} as const;
+/**
+ * api for an API write or advance for a clock advance.
+ */
+export type Kind = OpenEnum<typeof Kind>;
+
 export type Step = {
+  /**
+   * Advance that produced this step, if any.
+   */
+  advanceId: string | null;
+  /**
+   * api for an API write or advance for a clock advance.
+   */
+  kind: Kind;
   /**
    * HTTP method and path of the request that produced this step, without the query string, for example POST /v1/widgets.
    */
@@ -17,13 +40,38 @@ export type Step = {
    * Step number. Use it as at_step when you fork.
    */
   step: number;
+  /**
+   * Clock after the step.
+   */
+  timeAfter: Date | null;
+  /**
+   * Clock before the step.
+   */
+  timeBefore: Date | null;
 };
 
 /** @internal */
-export const Step$inboundSchema: z.ZodMiniType<Step, unknown> = z.object({
-  label: types.string(),
-  step: types.number(),
-});
+export const Kind$inboundSchema: z.ZodMiniType<Kind, unknown> = openEnums
+  .inboundSchema(Kind);
+
+/** @internal */
+export const Step$inboundSchema: z.ZodMiniType<Step, unknown> = z.pipe(
+  z.object({
+    advance_id: types.nullable(types.string()),
+    kind: Kind$inboundSchema,
+    label: types.string(),
+    step: types.number(),
+    time_after: types.nullable(types.date()),
+    time_before: types.nullable(types.date()),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "advance_id": "advanceId",
+      "time_after": "timeAfter",
+      "time_before": "timeBefore",
+    });
+  }),
+);
 
 export function stepFromJSON(
   jsonString: string,

package/src/models/world-build.ts

@@ -3,6 +3,7 @@
  */
 
 import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import { OpenEnum } from "../types/enums.js";
@@ -14,6 +15,32 @@ import {
   WorldDataSummary$inboundSchema,
 } from "./world-data-summary.js";
 
+/**
+ * Selected model provider. Absent for builds created before provider selection.
+ */
+export const WorldBuildBuilder = {
+  Openai: "openai",
+  Claude: "claude",
+} as const;
+/**
+ * Selected model provider. Absent for builds created before provider selection.
+ */
+export type WorldBuildBuilder = OpenEnum<typeof WorldBuildBuilder>;
+
+/**
+ * Outcome of the most recent plan submission.
+ */
+export const WorldBuildLastSubmission = {
+  Accepted: "accepted",
+  Rejected: "rejected",
+} as const;
+/**
+ * Outcome of the most recent plan submission.
+ */
+export type WorldBuildLastSubmission = OpenEnum<
+  typeof WorldBuildLastSubmission
+>;
+
 /**
  * Current phase of starting-data preparation.
  */
@@ -29,13 +56,45 @@ export const WorldBuildStage = {
 export type WorldBuildStage = OpenEnum<typeof WorldBuildStage>;
 
 export type WorldBuild = {
+  /**
+   * Selected model provider. Absent for builds created before provider selection.
+   */
+  builder?: WorldBuildBuilder | undefined;
+  /**
+   * Outcome of the most recent plan submission.
+   */
+  lastSubmission?: WorldBuildLastSubmission | undefined;
+  /**
+   * Name of the most recent tool. Tool arguments and output are private.
+   */
+  lastTool?: string | undefined;
   /**
    * Current phase of starting-data preparation.
    */
   stage: WorldBuildStage;
+  /**
+   * Number of submitted starting-data plans.
+   */
+  submissions?: number | undefined;
   summary?: WorldDataSummary | undefined;
+  /**
+   * Number of agent tool calls.
+   */
+  toolCalls?: number | undefined;
 };
 
+/** @internal */
+export const WorldBuildBuilder$inboundSchema: z.ZodMiniType<
+  WorldBuildBuilder,
+  unknown
+> = openEnums.inboundSchema(WorldBuildBuilder);
+
+/** @internal */
+export const WorldBuildLastSubmission$inboundSchema: z.ZodMiniType<
+  WorldBuildLastSubmission,
+  unknown
+> = openEnums.inboundSchema(WorldBuildLastSubmission);
+
 /** @internal */
 export const WorldBuildStage$inboundSchema: z.ZodMiniType<
   WorldBuildStage,
@@ -44,10 +103,24 @@ export const WorldBuildStage$inboundSchema: z.ZodMiniType<
 
 /** @internal */
 export const WorldBuild$inboundSchema: z.ZodMiniType<WorldBuild, unknown> = z
-  .object({
-    stage: WorldBuildStage$inboundSchema,
-    summary: types.optional(WorldDataSummary$inboundSchema),
-  });
+  .pipe(
+    z.object({
+      builder: types.optional(WorldBuildBuilder$inboundSchema),
+      last_submission: types.optional(WorldBuildLastSubmission$inboundSchema),
+      last_tool: types.optional(types.string()),
+      stage: WorldBuildStage$inboundSchema,
+      submissions: types.optional(types.number()),
+      summary: types.optional(WorldDataSummary$inboundSchema),
+      tool_calls: types.optional(types.number()),
+    }),
+    z.transform((v) => {
+      return remap$(v, {
+        "last_submission": "lastSubmission",
+        "last_tool": "lastTool",
+        "tool_calls": "toolCalls",
+      });
+    }),
+  );
 
 export function worldBuildFromJSON(
   jsonString: string,

package/src/models/world.ts

@@ -34,11 +34,19 @@ export const WorldStatus = {
 export type WorldStatus = OpenEnum<typeof WorldStatus>;
 
 export type World = {
+  /**
+   * Current clock advance operation ID, or null.
+   */
+  activeAdvanceId: string | null;
   build?: WorldBuild | undefined;
   /**
    * Time when the World build started.
    */
   createdAt: Date;
+  /**
+   * Current shared simulated time.
+   */
+  currentTime: Date;
   error: WorldError | null;
   /**
    * World ID.
@@ -56,6 +64,10 @@ export type World = {
    * Simulator IDs in member order.
    */
   simulators: Array<string>;
+  /**
+   * Initial simulated time. Before first Start this is the default time.
+   */
+  startTime: Date;
   /**
    * building while the build runs; ready when it can be started; running or stopped once its Simulations exist; failed when building or first start fails; canceled when the build was canceled.
    */
@@ -69,18 +81,24 @@ export const WorldStatus$inboundSchema: z.ZodMiniType<WorldStatus, unknown> =
 /** @internal */
 export const World$inboundSchema: z.ZodMiniType<World, unknown> = z.pipe(
   z.object({
+    active_advance_id: types.nullable(types.string()),
     build: types.optional(WorldBuild$inboundSchema),
     created_at: types.date(),
+    current_time: types.date(),
     error: types.nullable(WorldError$inboundSchema),
     id: types.string(),
     instructions: types.string(),
     simulations: z.array(WorldSimulation$inboundSchema),
     simulators: z.array(types.string()),
+    start_time: types.date(),
     status: WorldStatus$inboundSchema,
   }),
   z.transform((v) => {
     return remap$(v, {
+      "active_advance_id": "activeAdvanceId",
       "created_at": "createdAt",
+      "current_time": "currentTime",
+      "start_time": "startTime",
     });
   }),
 );

package/src/sdk/simulations.ts

@@ -2,10 +2,13 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import { simulationsAdvanceSimulationTime } from "../funcs/simulations-advance-simulation-time.js";
 import { simulationsCreateSimulation } from "../funcs/simulations-create-simulation.js";
 import { simulationsDeleteSimulation } from "../funcs/simulations-delete-simulation.js";
 import { simulationsForkSimulation } from "../funcs/simulations-fork-simulation.js";
+import { simulationsGetSimulationAdvance } from "../funcs/simulations-get-simulation-advance.js";
 import { simulationsGetSimulation } from "../funcs/simulations-get-simulation.js";
+import { simulationsListSimulationAdvanceEvents } from "../funcs/simulations-list-simulation-advance-events.js";
 import { simulationsListSimulationSteps } from "../funcs/simulations-list-simulation-steps.js";
 import { simulationsListSimulations } from "../funcs/simulations-list-simulations.js";
 import { simulationsMintSimulationToken } from "../funcs/simulations-mint-simulation-token.js";
@@ -85,6 +88,57 @@ export class Simulations extends ClientSDK {
     ));
   }
 
+  /**
+   * Advance Simulation Time
+   *
+   * @remarks
+   * Schedules an absolute clock advance. Each successful advance commits all due local events in one step. World members advance through their World. Poll the returned operation until it completes.
+   */
+  async advanceSimulationTime(
+    request: operations.AdvanceSimulationTimeRequest,
+    options?: RequestOptions,
+  ): Promise<models.ClockAdvance> {
+    return unwrapAsync(simulationsAdvanceSimulationTime(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Simulation Clock Advance
+   *
+   * @remarks
+   * Returns durable clock progress, the event count, and the committed step or failure.
+   */
+  async getSimulationAdvance(
+    request: operations.GetSimulationAdvanceRequest,
+    options?: RequestOptions,
+  ): Promise<models.ClockAdvance> {
+    return unwrapAsync(simulationsGetSimulationAdvance(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List Clock Advance Events
+   *
+   * @remarks
+   * Returns the ordered event trace for a committed advance. The Simulation must be running or paused. Forks retain traces in their inherited state.
+   */
+  async listSimulationAdvanceEvents(
+    request: operations.ListSimulationAdvanceEventsRequest,
+    options?: RequestOptions,
+  ): Promise<models.ListAdvanceEventsOutputBody> {
+    return unwrapAsync(simulationsListSimulationAdvanceEvents(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Fork Simulation
    *

package/src/sdk/worlds.ts

@@ -2,9 +2,11 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import { worldsAdvanceWorldTime } from "../funcs/worlds-advance-world-time.js";
 import { worldsBuildWorld } from "../funcs/worlds-build-world.js";
 import { worldsCancelWorldBuild } from "../funcs/worlds-cancel-world-build.js";
 import { worldsDeleteWorld } from "../funcs/worlds-delete-world.js";
+import { worldsGetWorldAdvance } from "../funcs/worlds-get-world-advance.js";
 import { worldsGetWorld } from "../funcs/worlds-get-world.js";
 import { worldsListWorlds } from "../funcs/worlds-list-worlds.js";
 import { worldsStartWorld } from "../funcs/worlds-start-world.js";
@@ -83,6 +85,40 @@ export class Worlds extends ClientSDK {
     ));
   }
 
+  /**
+   * Advance World Time
+   *
+   * @remarks
+   * Fences all members, advances each local clock, and returns a durable operation. A partial failure keeps members fenced while the operation retries. The World clock changes after all members commit.
+   */
+  async advanceWorldTime(
+    request: operations.AdvanceWorldTimeRequest,
+    options?: RequestOptions,
+  ): Promise<models.ClockAdvance> {
+    return unwrapAsync(worldsAdvanceWorldTime(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get World Clock Advance
+   *
+   * @remarks
+   * Returns durable progress for each member. Members remain fenced until the whole advance can finish.
+   */
+  async getWorldAdvance(
+    request: operations.GetWorldAdvanceRequest,
+    options?: RequestOptions,
+  ): Promise<models.ClockAdvance> {
+    return unwrapAsync(worldsGetWorldAdvance(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Cancel World Build
    *