@myagentroam/protocol 0.10.7 → 0.10.9

package/dist/model-usage.js

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+export const MODEL_USAGE_VERSION = 1;
+export const MODEL_USAGE_RETENTION_MS = 90 * 86_400_000;
+export const MODEL_USAGE_OUTBOX_RETENTION_MS = 7 * 86_400_000;
+export const MODEL_USAGE_BATCH_LIMIT = 64;
+export const MODEL_USAGE_BATCH_BYTES = 262_144;
+const identifier = z.string().min(1).max(256);
+const time = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+export const usageCountSchema = z.string().regex(/^(0|[1-9][0-9]{0,37})$/);
+export const usageRunnerSchema = z.enum(['mar-agent', 'codex', 'claude-code', 'opencode']);
+export const usagePurposeSchema = z.enum(['conversation', 'compact', 'title', 'other']);
+export const modelUsageCapabilitySchema = z.object({ apiVersion: z.literal(1) }).strict();
+/** A non-executable assertion, signed and verified only by the Server. */
+export const modelUsageGrantClaimsSchema = z
+    .object({
+    audience: z.literal('model-usage-v1'),
+    scopeId: z.string().uuid(),
+    nodeId: identifier,
+    userId: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    mode: z.enum(['work', 'conversation']),
+    issuedAt: time,
+    expiresAt: time
+})
+    .strict();
+export const modelUsageGrantSchema = z
+    .object({
+    scopeId: z.string().uuid(),
+    token: z.string().min(1).max(2048)
+})
+    .strict();
+export const modelUsageRecordSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    recordId: identifier,
+    requestId: identifier,
+    revision: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    scopeId: z.string().uuid(),
+    runner: usageRunnerSchema,
+    sessionId: identifier,
+    runId: identifier,
+    modelConfigurationId: identifier.optional(),
+    modelName: identifier.optional(),
+    provider: identifier.optional(),
+    requestedModel: identifier.optional(),
+    actualModel: identifier.optional(),
+    responseId: identifier.optional(),
+    purpose: usagePurposeSchema,
+    agentRole: z.enum(['root', 'subagent']),
+    startedAt: time,
+    endedAt: time.optional(),
+    state: z.enum(['running', 'succeeded', 'failed', 'cancelled', 'interrupted']),
+    inputTokens: usageCountSchema.optional(),
+    outputTokens: usageCountSchema.optional(),
+    cacheReadTokens: usageCountSchema.optional(),
+    cacheWriteTokens: usageCountSchema.optional(),
+    reasoningTokens: usageCountSchema.optional(),
+    coverage: z.enum(['request', 'partial']).default('request')
+})
+    .strict()
+    .superRefine((record, context) => {
+    if ((record.state === 'running') !== (record.endedAt === undefined))
+        context.addIssue({ code: 'custom', message: 'Usage outcome and end time do not match.' });
+    if (record.endedAt !== undefined && record.endedAt < record.startedAt)
+        context.addIssue({ code: 'custom', message: 'Usage end time precedes its start.' });
+});
+export const modelUsageBatchSchema = z
+    .object({
+    apiVersion: z.literal(1),
+    entries: z
+        .array(z.object({ grant: modelUsageGrantSchema, record: modelUsageRecordSchema }).strict())
+        .min(1)
+        .max(MODEL_USAGE_BATCH_LIMIT)
+})
+    .strict();
+export const modelUsageAckSchema = z
+    .object({
+    apiVersion: z.literal(1),
+    results: z
+        .array(z
+        .object({
+        recordId: identifier,
+        revision: z.number().int().positive(),
+        status: z.enum(['accepted', 'rejected']),
+        code: z
+            .enum([
+            'USAGE_GRANT_INVALID',
+            'USAGE_EXPIRED',
+            'USAGE_USER_DELETED',
+            'USAGE_CONFLICT',
+            'USAGE_TIME_INVALID'
+        ])
+            .optional()
+    })
+        .strict())
+        .max(MODEL_USAGE_BATCH_LIMIT)
+})
+    .strict();
+export const personalUsageQuerySchema = z
+    .object({
+    from: z.coerce.number().int().nonnegative(),
+    to: z.coerce.number().int().nonnegative(),
+    timeZone: z
+        .string()
+        .min(1)
+        .max(100)
+        .refine((value) => {
+        try {
+            new Intl.DateTimeFormat('en', { timeZone: value });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }),
+    runner: usageRunnerSchema.optional(),
+    model: z.string().min(1).max(800).optional(),
+    mode: z.enum(['work', 'conversation']).optional(),
+    purpose: usagePurposeSchema.optional()
+})
+    .strict()
+    .refine((value) => value.to > value.from && value.to - value.from <= MODEL_USAGE_RETENTION_MS, {
+    message: 'Usage range must be positive and no longer than 90 days.'
+});

package/dist/skill.d.ts

@@ -272,16 +272,16 @@ export declare const skillInstallMetadataSchema: z.ZodObject<{
     contentHash: z.ZodString;
     installedAt: z.ZodNumber;
 }, "strict", z.ZodTypeAny, {
+    schemaVersion: 1;
     commitSha: string;
     contentHash: string;
-    schemaVersion: 1;
     favoriteId: string;
     versionId: string;
     installedAt: number;
 }, {
+    schemaVersion: 1;
     commitSha: string;
     contentHash: string;
-    schemaVersion: 1;
     favoriteId: string;
     versionId: string;
     installedAt: number;

package/dist/tool-result-resource.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const toolResultResourceInputSchema: z.ZodObject<{
+    resourceRef: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+    maxBytes: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    resourceRef: string;
+    cursor?: string | undefined;
+    maxBytes?: number | undefined;
+}, {
+    resourceRef: string;
+    cursor?: string | undefined;
+    maxBytes?: number | undefined;
+}>;
+export type ToolResultResourceInput = z.infer<typeof toolResultResourceInputSchema>;
+export declare const toolResultResourcePageSchema: z.ZodObject<{
+    resourceRef: z.ZodString;
+    type: z.ZodLiteral<"file_changes">;
+    version: z.ZodLiteral<1>;
+    format: z.ZodLiteral<"unified-diff">;
+    sha256: z.ZodString;
+    byteSize: z.ZodNumber;
+    content: z.ZodString;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "file_changes";
+    resourceRef: string;
+    version: 1;
+    format: "unified-diff";
+    sha256: string;
+    byteSize: number;
+    content: string;
+    nextCursor?: string | undefined;
+}, {
+    type: "file_changes";
+    resourceRef: string;
+    version: 1;
+    format: "unified-diff";
+    sha256: string;
+    byteSize: number;
+    content: string;
+    nextCursor?: string | undefined;
+}>;
+export type ToolResultResourcePage = z.infer<typeof toolResultResourcePageSchema>;
+export declare const fileChangeDiffSchema: z.ZodDiscriminatedUnion<"status", [z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    source: z.ZodLiteral<"TOOL_CHANGE">;
+    resourceRef: z.ZodString;
+    format: z.ZodLiteral<"unified-diff">;
+    byteSize: z.ZodNumber;
+    sha256: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    status: "available";
+    source: "TOOL_CHANGE";
+    resourceRef: string;
+    format: "unified-diff";
+    sha256: string;
+    byteSize: number;
+}, {
+    status: "available";
+    source: "TOOL_CHANGE";
+    resourceRef: string;
+    format: "unified-diff";
+    sha256: string;
+    byteSize: number;
+}>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodEnum<["binary", "limit-exceeded", "capture-failed", "storage-failed"]>;
+}, "strict", z.ZodTypeAny, {
+    status: "unavailable";
+    reason: "binary" | "limit-exceeded" | "capture-failed" | "storage-failed";
+}, {
+    status: "unavailable";
+    reason: "binary" | "limit-exceeded" | "capture-failed" | "storage-failed";
+}>]>;
+export type FileChangeDiff = z.infer<typeof fileChangeDiffSchema>;

package/dist/tool-result-resource.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export const toolResultResourceInputSchema = z
+    .object({
+    resourceRef: z.string().uuid(),
+    cursor: z.string().min(1).max(1024).optional(),
+    maxBytes: z
+        .number()
+        .int()
+        .min(4)
+        .max(256 * 1024)
+        .optional()
+})
+    .strict();
+export const toolResultResourcePageSchema = z
+    .object({
+    resourceRef: z.string().uuid(),
+    type: z.literal('file_changes'),
+    version: z.literal(1),
+    format: z.literal('unified-diff'),
+    sha256: z.string().regex(/^[a-f0-9]{64}$/u),
+    byteSize: z
+        .number()
+        .int()
+        .min(0)
+        .max(16 * 1024 * 1024),
+    content: z.string().max(256 * 1024),
+    nextCursor: z.string().min(1).max(1024).optional()
+})
+    .strict();
+export const fileChangeDiffSchema = z.discriminatedUnion('status', [
+    z
+        .object({
+        status: z.literal('available'),
+        source: z.literal('TOOL_CHANGE'),
+        resourceRef: z.string().uuid(),
+        format: z.literal('unified-diff'),
+        byteSize: z
+            .number()
+            .int()
+            .min(0)
+            .max(16 * 1024 * 1024),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/u)
+    })
+        .strict(),
+    z
+        .object({
+        status: z.literal('unavailable'),
+        reason: z.enum(['binary', 'limit-exceeded', 'capture-failed', 'storage-failed'])
+    })
+        .strict()
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/protocol",
-  "version": "0.10.7",
+  "version": "0.10.9",
   "description": "Shared runtime protocol schemas for MyAgentRoam.",
   "license": "Apache-2.0",
   "type": "module",