@nyte-ai/schema 0.0.0-stage → 0.0.19

package/dist/chunks/browser-0byq2fja.js

@@ -0,0 +1,50 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+
+// src/primitives.ts
+import { Type } from "typebox";
+function pagedSchema2(item) {
+  return standard2(withJson2(Type.Object({ items: Type.Array(item), next: nullable2(idSchema2()) })));
+}
+var ParentFilterType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("all") }),
+  Type.Object({ kind: Type.Literal("roots") }),
+  Type.Object({ kind: Type.Literal("children"), session: idSchema2() })
+]);
+var CapabilityWireType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("available") }),
+  Type.Object({ kind: Type.Literal("unsupported"), reason: Type.String() }),
+  Type.Object({ kind: Type.Literal("denied"), reason: Type.String() }),
+  Type.Object({
+    kind: Type.Literal("unavailable"),
+    retry: Type.Enum(["allowed", "manual"]),
+    reason: Type.String()
+  })
+]);
+var IdentityChallengeType2 = Type.Object({
+  hostId: idSchema2(),
+  nonce: Type.String(),
+  signature: Type.String(),
+  publicKey: Type.String()
+});
+var HostDescriptionType2 = Type.Object({
+  name: Type.String(),
+  platform: Type.String(),
+  version: Type.String()
+});
+var ParentFilterSchema2 = standard2(ParentFilterType2);
+var CapabilityWireSchema2 = standard2(CapabilityWireType2);
+var IdentityChallengeSchema2 = standard2(IdentityChallengeType2);
+var HostDescriptionSchema2 = standard2(HostDescriptionType2);
+
+export { pagedSchema2, ParentFilterType2, CapabilityWireType2, IdentityChallengeType2, HostDescriptionType2, ParentFilterSchema2, CapabilityWireSchema2, IdentityChallengeSchema2, HostDescriptionSchema2 };

package/dist/chunks/browser-0chm3654.js

@@ -0,0 +1,125 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  withJson2
+} from "./browser-sgwxbek9.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+import {
+  ModelRefType2
+} from "./browser-0sbkxgkx.js";
+import {
+  ConfigurationPatchType2,
+  ConfigurationType2
+} from "./browser-ynj8v9ad.js";
+import {
+  ValidationIssueType2
+} from "./browser-1sfp0bcx.js";
+import {
+  DeliveryType2,
+  UserContentType2,
+  PositionType2,
+  MessageSourceType2
+} from "./browser-hq5q56sf.js";
+
+// src/heads.ts
+import { Type } from "typebox";
+var ABANDONED = Type.Union([
+  Type.Literal("keep"),
+  Type.Object({ summarize: Type.Object({ instructions: Type.Optional(Type.String()) }) })
+]);
+var TreeNodeType2 = Type.Object({
+  id: idSchema2(),
+  parent: nullable2(idSchema2()),
+  depth: Type.Number(),
+  branch: Type.Boolean(),
+  active: Type.Boolean(),
+  heads: Type.Array(idSchema2()),
+  kind: Type.Enum(["user", "part", "compaction", "branchSummary"]),
+  partKind: nullable2(Type.String()),
+  preview: Type.String(),
+  at: Type.Number(),
+  run: nullable2(idSchema2())
+});
+var TreeViewType2 = Type.Object({
+  revision: nullable2(idSchema2()),
+  tip: PositionType2,
+  nodes: Type.Array(TreeNodeType2)
+});
+var CreateHeadOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("created"), basedOn: PositionType2 }),
+  Type.Object({ kind: Type.Literal("exists") }),
+  Type.Object({ kind: Type.Literal("missing-source") })
+]);
+var MergeOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("merged"), revision: idSchema2() }),
+  Type.Object({ kind: Type.Literal("stale"), revision: idSchema2() }),
+  Type.Object({ kind: Type.Literal("diverged"), base: PositionType2 }),
+  Type.Object({ kind: Type.Literal("is-main") }),
+  Type.Object({ kind: Type.Literal("busy"), run: idSchema2() })
+]);
+var RemoveHeadOutcomeType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("removed") }),
+  Type.Object({ kind: Type.Literal("missing") }),
+  Type.Object({ kind: Type.Literal("is-main") }),
+  Type.Object({ kind: Type.Literal("busy"), run: idSchema2() })
+]);
+var MoveOutcomeType2 = Type.Union([
+  Type.Object({
+    kind: Type.Literal("moved"),
+    revision: idSchema2(),
+    position: PositionType2,
+    summary: nullable2(idSchema2()),
+    handback: nullable2(UserContentType2)
+  }),
+  Type.Object({ kind: Type.Literal("stale"), revision: idSchema2() }),
+  Type.Object({ kind: Type.Literal("busy"), run: idSchema2() }),
+  Type.Object({ kind: Type.Literal("pending-input"), messages: Type.Array(idSchema2()) }),
+  Type.Object({ kind: Type.Literal("missing-target") }),
+  Type.Object({ kind: Type.Literal("summary-failed"), reason: Type.String() })
+]);
+var MoveOptionsType2 = Type.Object({
+  running: Type.Optional(Type.Enum(["refuse", "stop"])),
+  abandoned: Type.Optional(ABANDONED),
+  expect: Type.Optional(idSchema2())
+});
+var SendOptionsType2 = Type.Object({
+  delivery: Type.Optional(DeliveryType2),
+  replace: Type.Optional(idSchema2()),
+  running: Type.Optional(Type.Enum(["refuse", "stop"])),
+  abandoned: Type.Optional(ABANDONED),
+  expect: Type.Optional(idSchema2()),
+  position: Type.Optional(Type.Union([
+    Type.Object({ kind: Type.Literal("last") }),
+    Type.Object({ kind: Type.Literal("before"), message: idSchema2() })
+  ])),
+  source: Type.Optional(MessageSourceType2),
+  configuration: Type.Optional(Type.Union([ConfigurationType2, ConfigurationPatchType2])),
+  id: Type.Optional(idSchema2())
+});
+var ConfigureOutcomeType2 = Type.Union([
+  Type.Object({
+    kind: Type.Literal("configured"),
+    selected: ConfigurationType2,
+    revision: idSchema2()
+  }),
+  Type.Object({ kind: Type.Literal("unknown-model"), model: ModelRefType2 }),
+  Type.Object({ kind: Type.Literal("unknown-agent"), agent: Type.String() }),
+  Type.Object({ kind: Type.Literal("invalid"), issues: Type.Array(ValidationIssueType2) })
+]);
+var TreeNodeSchema2 = standard2(TreeNodeType2);
+var TreeViewSchema2 = standard2(TreeViewType2);
+var CreateHeadOutcomeSchema2 = standard2(CreateHeadOutcomeType2);
+var MergeOutcomeSchema2 = standard2(MergeOutcomeType2);
+var RemoveHeadOutcomeSchema2 = standard2(RemoveHeadOutcomeType2);
+var MoveOutcomeSchema2 = standard2(MoveOutcomeType2);
+var MoveOptionsSchema2 = standard2(MoveOptionsType2);
+var SendOptionsSchema2 = standard2(withJson2(SendOptionsType2));
+var ConfigureOutcomeSchema2 = standard2(withJson2(ConfigureOutcomeType2));
+
+export { TreeNodeType2, TreeViewType2, CreateHeadOutcomeType2, MergeOutcomeType2, RemoveHeadOutcomeType2, MoveOutcomeType2, MoveOptionsType2, SendOptionsType2, ConfigureOutcomeType2, TreeNodeSchema2, TreeViewSchema2, CreateHeadOutcomeSchema2, MergeOutcomeSchema2, RemoveHeadOutcomeSchema2, MoveOutcomeSchema2, MoveOptionsSchema2, SendOptionsSchema2, ConfigureOutcomeSchema2 };

package/dist/chunks/browser-0g0z3617.js

@@ -0,0 +1,47 @@
+import {
+  GitHubPullRequestInputType2,
+  GitHubStateSchema2,
+  GitHubAccountStateSchema2,
+  GitHubPullRequestOutcomeSchema2
+} from "./browser-ekbecx9r.js";
+import {
+  wireObject2,
+  WORKSPACE2,
+  ON_WORKSPACE2
+} from "./browser-r87w64mz.js";
+
+// src/wire/operations/github.ts
+var READ = { authority: "participant", scope: "workspace", capability: "github" };
+var WRITE = { authority: "owner", scope: "workspace", capability: "github" };
+var ACCOUNT = { authority: "participant", scope: "host" };
+var ACCOUNT_WRITE = { authority: "owner", scope: "host" };
+var NO_INPUT = wireObject2({});
+var GITHUB_OPERATIONS2 = {
+  "github.account": {
+    ...ACCOUNT,
+    kind: "query",
+    input: NO_INPUT,
+    output: GitHubAccountStateSchema2
+  },
+  "github.signIn": {
+    ...ACCOUNT_WRITE,
+    kind: "command",
+    input: NO_INPUT,
+    output: GitHubAccountStateSchema2
+  },
+  "github.signOut": {
+    ...ACCOUNT_WRITE,
+    kind: "command",
+    input: NO_INPUT,
+    output: GitHubAccountStateSchema2
+  },
+  "github.state": { ...READ, kind: "query", input: ON_WORKSPACE2, output: GitHubStateSchema2 },
+  "github.createPullRequest": {
+    ...WRITE,
+    kind: "command",
+    input: wireObject2({ ...WORKSPACE2, input: GitHubPullRequestInputType2 }),
+    output: GitHubPullRequestOutcomeSchema2
+  }
+};
+
+export { GITHUB_OPERATIONS2 };

package/dist/chunks/browser-0khex2b1.js

@@ -0,0 +1,33 @@
+// src/model/text.ts
+function contentText2(content, separator = `
+`) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((block) => block.type === "text").map((block) => block.text).join(separator);
+}
+function getSystemMessageText2(message) {
+  const parts = [contentText2(message.content)];
+  for (const text of Object.values(message.sections ?? {})) {
+    if (text !== null)
+      parts.push(text);
+  }
+  return parts.filter((part) => part.length > 0).join(`
+
+`);
+}
+function renderSystemMessageUpdate2(message) {
+  const parts = [];
+  const text = contentText2(message.content);
+  if (text.length > 0)
+    parts.push(text);
+  for (const [name, value] of Object.entries(message.sections ?? {})) {
+    parts.push(value === null ? `Removed system prompt section "${name}".` : `Updated system prompt section "${name}":
+
+${value}`);
+  }
+  return parts.join(`
+
+`);
+}
+
+export { contentText2, getSystemMessageText2, renderSystemMessageUpdate2 };

package/dist/chunks/browser-0sbkxgkx.js

@@ -0,0 +1,115 @@
+import {
+  standard2
+} from "./browser-vzc3r2r3.js";
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  nullable2
+} from "./browser-4et7qtz3.js";
+
+// src/models.ts
+import { Type } from "typebox";
+var ModelRefType2 = Type.Object({ provider: Type.String(), id: Type.String() });
+var ThinkingType2 = Type.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var UsageType2 = Type.Object({
+  input: Type.Number(),
+  output: Type.Number(),
+  cacheRead: Type.Number(),
+  cacheWrite: Type.Number(),
+  reasoning: nullable2(Type.Number()),
+  total: Type.Number(),
+  cost: Type.Object({
+    input: Type.Number(),
+    output: Type.Number(),
+    cacheRead: Type.Number(),
+    cacheWrite: Type.Number(),
+    total: Type.Number()
+  })
+});
+var ContextViewType2 = Type.Object({
+  tokens: Type.Number(),
+  window: Type.Number(),
+  lastRequest: nullable2(UsageType2)
+});
+var LoginMethodType2 = Type.Union([
+  Type.Object({ kind: Type.Literal("oauth") }),
+  Type.Object({ kind: Type.Literal("key") })
+]);
+var PROVIDER_LIMITS = Type.Array(Type.Object({
+  label: Type.String(),
+  used: Type.Number(),
+  limit: Type.Number(),
+  resetsAt: nullable2(Type.Number())
+}));
+var ModelAccountType2 = Type.Object({
+  provider: Type.String(),
+  id: Type.String(),
+  label: Type.String(),
+  method: LoginMethodType2,
+  active: Type.Boolean()
+});
+var ProviderUsageType2 = Type.Object({
+  provider: Type.String(),
+  name: Type.String(),
+  account: nullable2(ModelAccountType2),
+  state: Type.Union([
+    Type.Object({
+      kind: Type.Literal("ready"),
+      limits: PROVIDER_LIMITS,
+      observedAt: Type.Number(),
+      stale: Type.Boolean(),
+      error: nullable2(Type.String())
+    }),
+    Type.Object({
+      kind: Type.Literal("unavailable"),
+      reason: Type.Enum(["unsupported", "unconfigured", "failed"]),
+      message: Type.String()
+    })
+  ])
+});
+var ModelCapabilitiesType2 = Type.Object({ steer: Type.Boolean() });
+var ModelInfoType2 = Type.Object({
+  ref: ModelRefType2,
+  name: Type.String(),
+  reasoning: Type.Boolean(),
+  thinking: Type.Array(ThinkingType2),
+  defaultThinking: ThinkingType2,
+  fast: nullable2(ModelRefType2),
+  contextWindow: Type.Number(),
+  compactAt: Type.Number(),
+  maxOutput: Type.Number(),
+  input: Type.Array(Type.Enum(["text", "image"])),
+  capabilities: ModelCapabilitiesType2,
+  cost: Type.Object({
+    input: Type.Number(),
+    output: Type.Number(),
+    cacheRead: Type.Number(),
+    cacheWrite: Type.Number()
+  })
+});
+var ModelListingType2 = Type.Enum(["shown", "hidden", "favorite"]);
+var ModelCatalogViewType2 = Type.Object({
+  generation: idSchema2(),
+  default: nullable2(ModelRefType2),
+  providers: Type.Array(Type.Object({
+    id: Type.String(),
+    name: Type.String(),
+    credential: Type.Enum(["unknown", "missing", "configured", "verified", "failed"]),
+    methods: Type.Array(LoginMethodType2),
+    limits: PROVIDER_LIMITS,
+    models: Type.Array(ModelInfoType2),
+    listings: Type.Record(Type.String(), Type.Enum(["hidden", "favorite"]))
+  }))
+});
+var ModelRefSchema2 = standard2(ModelRefType2);
+var ThinkingSchema2 = standard2(ThinkingType2);
+var UsageSchema2 = standard2(UsageType2);
+var ContextViewSchema2 = standard2(ContextViewType2);
+var LoginMethodSchema2 = standard2(LoginMethodType2);
+var ModelAccountSchema2 = standard2(ModelAccountType2);
+var ProviderUsageSchema2 = standard2(ProviderUsageType2);
+var ModelInfoSchema2 = standard2(ModelInfoType2);
+var ModelCatalogViewSchema2 = standard2(ModelCatalogViewType2);
+
+export { ModelRefType2, ThinkingType2, UsageType2, ContextViewType2, LoginMethodType2, ModelAccountType2, ProviderUsageType2, ModelCapabilitiesType2, ModelInfoType2, ModelListingType2, ModelCatalogViewType2, ModelRefSchema2, ThinkingSchema2, UsageSchema2, ContextViewSchema2, LoginMethodSchema2, ModelAccountSchema2, ProviderUsageSchema2, ModelInfoSchema2, ModelCatalogViewSchema2 };

package/dist/chunks/browser-0xr6c36r.js

@@ -0,0 +1,106 @@
+import {
+  idSchema2
+} from "./browser-ypez6s7v.js";
+import {
+  GitCommitViewType2,
+  GitScopeType2,
+  DiffOptionsType2,
+  GitWriteType2,
+  GitStatusSchema2,
+  GitRefsViewSchema2,
+  GitFileSidesSchema2,
+  BlameViewSchema2,
+  ChangeSetSchema2,
+  PatchSetWireSchema2,
+  GitOutcomeSchema2
+} from "./browser-p691tcac.js";
+import {
+  pagedSchema2
+} from "./browser-0byq2fja.js";
+import {
+  wireObject2,
+  WORKSPACE2,
+  PATH2,
+  ON_WORKSPACE2,
+  ON_PATH2
+} from "./browser-r87w64mz.js";
+
+// src/wire/operations/git.ts
+import { Type } from "typebox";
+var READ = { authority: "participant", scope: "workspace", capability: "git" };
+var WRITE = { authority: "owner", scope: "workspace", capability: "git" };
+var GIT_COMPARE = { ...WORKSPACE2, scope: GitScopeType2, options: Type.Optional(DiffOptionsType2) };
+var GIT_PATHS_INPUT = wireObject2({
+  ...WORKSPACE2,
+  paths: Type.Array(Type.String()),
+  options: Type.Optional(GitWriteType2)
+});
+var GIT_COMPARE_INPUT = wireObject2(GIT_COMPARE);
+var GIT_OPERATIONS2 = {
+  "git.status": { ...READ, kind: "query", input: ON_WORKSPACE2, output: GitStatusSchema2 },
+  "git.watch": { ...READ, kind: "watch", input: ON_WORKSPACE2, output: GitStatusSchema2 },
+  "git.changes": { ...READ, kind: "query", input: GIT_COMPARE_INPUT, output: ChangeSetSchema2 },
+  "git.watchChanges": { ...READ, kind: "watch", input: GIT_COMPARE_INPUT, output: ChangeSetSchema2 },
+  "git.patches": {
+    ...READ,
+    kind: "stream",
+    input: wireObject2({ ...GIT_COMPARE, paths: Type.Array(Type.String()) }),
+    output: PatchSetWireSchema2
+  },
+  "git.contents": {
+    ...READ,
+    kind: "query",
+    input: wireObject2({ ...PATH2, scope: GitScopeType2 }),
+    output: GitFileSidesSchema2
+  },
+  "git.log": {
+    ...READ,
+    kind: "query",
+    input: wireObject2({
+      ...WORKSPACE2,
+      cursor: Type.Optional(idSchema2()),
+      limit: Type.Optional(Type.Number())
+    }),
+    output: pagedSchema2(GitCommitViewType2)
+  },
+  "git.refs": { ...READ, kind: "query", input: ON_WORKSPACE2, output: GitRefsViewSchema2 },
+  "git.blame": { ...READ, kind: "query", input: ON_PATH2, output: BlameViewSchema2 },
+  "git.stage": { ...WRITE, kind: "command", input: GIT_PATHS_INPUT, output: GitOutcomeSchema2 },
+  "git.unstage": { ...WRITE, kind: "command", input: GIT_PATHS_INPUT, output: GitOutcomeSchema2 },
+  "git.discard": { ...WRITE, kind: "command", input: GIT_PATHS_INPUT, output: GitOutcomeSchema2 },
+  "git.commit": {
+    ...WRITE,
+    kind: "command",
+    input: wireObject2({
+      ...WORKSPACE2,
+      input: Type.Object({
+        message: Type.String(),
+        files: Type.Union([Type.Literal("staged"), Type.Literal("all"), Type.Array(Type.String())])
+      }),
+      options: Type.Optional(GitWriteType2)
+    }),
+    output: GitOutcomeSchema2
+  },
+  "git.branch": {
+    ...WRITE,
+    kind: "command",
+    input: wireObject2({
+      ...WORKSPACE2,
+      input: Type.Object({ name: Type.String(), checkout: Type.Boolean() }),
+      options: Type.Optional(GitWriteType2)
+    }),
+    output: GitOutcomeSchema2
+  },
+  "git.push": {
+    ...WRITE,
+    kind: "command",
+    input: wireObject2({
+      ...WORKSPACE2,
+      input: Type.Optional(Type.Object({ setUpstream: Type.Optional(Type.Boolean()) })),
+      options: Type.Optional(GitWriteType2)
+    }),
+    output: GitOutcomeSchema2
+  }
+};
+
+export { GIT_OPERATIONS2 };