Agent Deployment SDK

client = AgentClient(
    api_key: Optional[str] = None,        # API key (or HIKIGAI_API_KEY env var)
    project_id: Optional[str] = None,     # Project ID (or HIKIGAI_PROJECT_ID env var)
    base_url: Optional[str] = None,       # API endpoint (defaults to production)
    timeout: float = 30.0,                # Request timeout in seconds
)

with AgentClient() as client:
    agent = client.deploy(config)
# Resources automatically released

job = client.jobs.enqueue(
    "agent.invoke",
    {"input": "Batch-code these notes"},
    agent_id=agent.id,
    priority="standard",
)
detail = client.jobs.wait(job.id)
print(detail.status, detail.result)

# Upload with metadata + optional object TTL
with open("note.pdf", "rb") as f:
    uploaded = client.storage.upload(
        app_id="app_123",
        file=f,
        filename="note.pdf",
        content_type="application/pdf",
        metadata={"visit_id": "v-42", "kind": "clinical-note"},
        ttl=86400,  # object expires in 24h (optional)
    )
print(uploaded.object_id, uploaded.size_bytes, uploaded.signed_url)

# Fresh download URL later
url = client.storage.signed_url("app_123", uploaded.object_id, ttl=3600)
print(url.signed_url, url.expires_at)

# Inspect one object
info = client.storage.get("app_123", uploaded.object_id)
print(info.original_filename, info.metadata, info.status)

# List with filters / pagination
page = client.storage.list(
    "app_123",
    content_type="application/pdf",
    status="active",
    limit=20,
    page=1,
)
for obj in page.objects:
    print(obj.object_id, obj.original_filename, obj.size_bytes)
print(page.total, page.total_pages)

client.storage.delete("app_123", uploaded.object_id)

from hikigai.agentsdk import RoomSession

room = RoomSession(
    base_url="https://backend.hikigaiplatform.io",  # required
    api_key="hikigai_...",      # or access_token=... or room_token=...
    project_id="your-project-id",
)

import asyncio
from hikigai.agentsdk import RoomSession

async def main():
    room = RoomSession(
        base_url="https://backend.hikigaiplatform.io",
        api_key="your-api-key",
        project_id="your-project-id",
    )
    async with room:
        await room.join("rounds-42")
        await room.publish("rounds-42", "update", {"status": "in_progress"})
        await room.who("rounds-42")
        async for frame in room:
            if frame.get("type") == "message":
                print(frame["event"], frame["data"], frame.get("seq"))
            elif frame.get("type") == "error":
                print("error", frame.get("code"), frame.get("message"))
                break

asyncio.run(main())

await room.join("call-1")
await room.rtc_join("call-1")  # rtc_joined arrives on the iterator (ice_servers, peers)
async for frame in room:
    if frame["type"] == "rtc_peer_joined" and frame.get("initiator"):
        await room.rtc_offer("call-1", frame["id"], await make_offer())
    elif frame["type"] == "rtc_offer":
        await room.rtc_answer("call-1", frame["sender"], await answer(frame["sdp"]))
    elif frame["type"] == "rtc_candidate":
        await add_ice(frame["sender"], frame["candidate"])

config = AgentConfig(
    name="medical-coder",
    display_name="Medical Coding Assistant",
    description="Extracts ICD-10 codes from clinical notes",
    instruction="You are a medical coding expert...",
    model="claude-3.5-sonnet",
    category="coding-billing",
    tags=["icd-10", "healthcare"],
    input_schema=InputSchema(fields={"note": StringField(required=True)}),
    output_schema=OutputSchema(fields={"codes": ArrayField()}),
    timeout=60,
    memory_mb=512,
    version="1.0.0",
    hipaa_compliant=True
)

from hikigai.agentsdk import AgentConfig, VadConfig

agent = client.deploy(AgentConfig(
    ...,
    input_modality="audio",
    output_modality="text",
    vad=VadConfig(
        silence_duration_ms=800,              # or override, e.g. 300
        end_of_speech_sensitivity="low",
        start_of_speech_sensitivity="low",
    ),
))

# Defaults when constructing VadConfig():
#   silence_duration_ms=800, sensitivities="low" / "low"

from hikigai.agentsdk import InputSchema, OutputSchema, StringField, IntegerField

input_schema = InputSchema(
    description="Patient information",
    fields={
        "patient_id": StringField(required=True),
        "age": IntegerField(required=True, minimum=0, maximum=150),
    }
)

output_schema = OutputSchema(
    description="Diagnosis results",
    fields={
        "diagnosis": StringField(),
        "confidence": IntegerField(minimum=0, maximum=100),
    }
)

from hikigai.agentsdk import AgentClient, AgentConfig, SubAgentConfig
from hikigai.agentsdk import InputSchema, OutputSchema, StringField

client = AgentClient()  # HIKIGAI_API_KEY + HIKIGAI_PROJECT_ID

config = AgentConfig(
    name="cpt2-note-workflow",
    display_name="CPT2 Note Workflow",
    description="Clean a clinical note, then reuse CPT2 from the marketplace",
    agent_type="sequential",
    model="gemini-2.5-flash",
    instruction="Pass the note through prep, then CPT Category II extraction.",
    version="1.0.0",
    category="coding-billing",
    input_schema=InputSchema(fields={"input": StringField(description="Clinical note")}),
    output_schema=OutputSchema(fields={"output": StringField(description="Coding result")}),
    sub_agents=[
        # Your own sub-agent — full instruction / schemas
        SubAgentConfig(
            name="note_cleaner",
            model="gemini-2.5-flash",
            instruction="Clean and structure the note for CPT II coding. Do not invent facts.",
            description="Prepares notes for coding",
            input_schema=InputSchema(fields={"input": StringField()}),
            output_schema=OutputSchema(fields={"output": StringField()}),
        ),
        # Marketplace reuse — name + source only (no id / instruction / schemas)
        SubAgentConfig(
            name="cpt2_code_agent",  # marketplace name or slug
            source="marketplace",
        ),
    ],
)

agent = client.deploy(config)
# Invoke with AppSDK: AppClient().agent(agent.slug).invoke({"input": "..."})